@codeyam/codeyam-cli 0.0.0 → 0.1.0-staging.036391e

package/background/src/lib/virtualized/project/writeMockDataTsx.js

@@ -0,0 +1,1229 @@
+import path from 'path';
+import writeFile from "../common/writeFile.js";
+import { DEFAULT_SCENARIO_NAME } from "../common/constants.js";
+import { deepMerge } from "../../../../../packages/generate/index.js";
+import { parseDocument } from 'htmlparser2';
+import { safeFileName } from "../../../../../packages/utils/index.js";
+import { cleanOutBoundary } from "../../../../../packages/ai/index.js";
+import { reconcileMockDataKeys } from "./reconcileMockDataKeys.js";
+/**
+ * Normalize useParams mock data by fixing the React Router splat param (*).
+ * The LLM often generates random string values for `*` (the splat param),
+ * but this param represents the URL path suffix after the matched route
+ * and should typically be empty string for default scenarios.
+ *
+ * Example: For route `/entity/:sha/*`, the `*` param contains everything
+ * after `/entity/:sha/`. An empty string means the default tab/view.
+ */
+function normalizeParamsMockData(mockData) {
+    const result = {};
+    for (const [key, value] of Object.entries(mockData)) {
+        // Check if this is a useParams mock data entry
+        if (key.includes('useParams') && value && typeof value === 'object') {
+            const paramsObj = value;
+            // If there's a `*` key (splat param), default it to empty string
+            // The splat param represents URL path suffix and is typically empty for default views
+            if ('*' in paramsObj) {
+                result[key] = {
+                    ...paramsObj,
+                    '*': '', // Default splat to empty string for default tab/view
+                };
+                continue;
+            }
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Convert comma-separated string values to arrays when they look like array data.
+ * This handles cases where the LLM generates strings like "color,size" instead
+ * of arrays like ["color", "size"] due to schema type misdetection.
+ */
+function convertCommaSeparatedStringsToArrays(mockData) {
+    const result = {};
+    for (const [key, value] of Object.entries(mockData)) {
+        if (typeof value === 'string') {
+            const asArray = parseCommaSeparatedStringAsArray(value, key);
+            if (asArray !== null) {
+                result[key] = asArray;
+                console.log(`CodeYam: Converted comma-separated string to array for key "${key}": "${value}" -> [${asArray.map((s) => `"${s}"`).join(', ')}]`);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        else if (value !== null &&
+            typeof value === 'object' &&
+            !Array.isArray(value)) {
+            // Recursively process nested objects
+            result[key] = convertCommaSeparatedStringsToArrays(value);
+        }
+        else if (Array.isArray(value)) {
+            // Recursively process arrays (each element could be an object)
+            result[key] = value.map((item) => {
+                if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+                    return convertCommaSeparatedStringsToArrays(item);
+                }
+                return item;
+            });
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Detect if a string looks like a comma-separated list that should be an array.
+ */
+function parseCommaSeparatedStringAsArray(value, key) {
+    if (!value.includes(',')) {
+        return null;
+    }
+    // Heuristic: if the key name suggests it's an array field, convert it
+    // Check this FIRST before sentence detection, since "color, size" looks like
+    // a sentence but should be converted to ["color", "size"] for _attributes fields
+    const arrayFieldPatterns = [
+        /_attributes$/i,
+        /_ids$/i,
+        /_items$/i,
+        /_tags$/i,
+        /_values$/i,
+        /_types$/i,
+        /_names$/i,
+        /_keys$/i,
+        /^attributes$/i,
+        /^items$/i,
+        /^tags$/i,
+        /^values$/i,
+    ];
+    const looksLikeArrayField = arrayFieldPatterns.some((pattern) => pattern.test(key));
+    if (looksLikeArrayField) {
+        // For array-like fields, only reject if it contains newlines (likely prose)
+        if (value.includes('\n')) {
+            return null;
+        }
+        const parts = value.split(',').map((s) => s.trim());
+        return parts.filter((s) => s.length > 0);
+    }
+    // For non-array-named fields, apply stricter sentence detection
+    // Looks like a sentence: "Hello, world"
+    if (/,\s+[a-z]/.test(value)) {
+        return null;
+    }
+    if (value.includes('\n')) {
+        return null;
+    }
+    return null;
+}
+/**
+ * Return true when `markup` contains 0 or >1 meaningful
+ * top-level nodes (element *or* non-blank text), so React
+ * would require you to wrap it (e.g. `<> … </>`).
+ */
+export function needsFragment(markup) {
+    // Trim leading/trailing whitespace so we don’t get a bogus
+    // text node at the front.
+    const doc = parseDocument(markup.trim(), {
+        recognizeSelfClosing: true, // <br/> recognised as self-closing
+        lowerCaseAttributeNames: false, // keep SVG / React casing intact
+        lowerCaseTags: false,
+    });
+    // htmlparser2 gives you an array of document-level nodes
+    const roots = doc.childNodes.filter((n) => {
+        if (n.type === 'text' || n.type === 'cdata') {
+            // keep only *non-blank* text
+            return n.data.trim() !== '';
+        }
+        // element, comment, directive → always count
+        return true;
+    });
+    return roots.length !== 1;
+}
+const getLevelSpacing = (level) => '    '.repeat(level);
+/**
+ * Strip type parameters like <typeof loader> from a string.
+ * e.g. "useLoaderData<typeof loader>()" becomes "useLoaderData()"
+ */
+const cleanOutTypes = (str) => {
+    return cleanOutBoundary(str, '<', '>').replace(/<>/g, '');
+};
+const safeString = (s, level) => {
+    // NOTE: We no longer strip arguments from top-level function keys (level 2)
+    // because normalizeMockData now handles merging duplicate keys while preserving
+    // original keys when there's only one call site. This ensures constructMockCode
+    // can look up data with the full key (e.g., "useCustomSizes(projectSlug)").
+    //
+    // Only escape quotes and newlines for safe string output.
+    return s?.replace ? s.replace(/"/g, "'").replace(/\n/g, '\\n') : s;
+};
+/**
+ * Clean up malformed LLM-generated function values.
+ * The LLM sometimes generates function values with an invalid "(function)" prefix like:
+ * - "(function)() => {}"
+ * - "(function)(event) => {}"
+ * - "(function)(id) => {}"
+ *
+ * This strips the prefix and adds TypeScript `any` type annotations to parameters.
+ * Returns null if the value doesn't match the malformed pattern.
+ */
+const cleanMalformedFunctionValue = (value) => {
+    // Match "(function)" followed by optional params in parens, then "=>"
+    const match = value.match(/^\(function\)(\([^)]*\))\s*=>\s*(.*)$/);
+    if (!match)
+        return null;
+    const [, paramsWithParens, body] = match;
+    // Extract parameter names and add `: any` type annotation
+    // e.g., "(event)" -> "(event: any)", "()" -> "()"
+    const params = paramsWithParens.slice(1, -1).trim(); // Remove outer parens
+    const typedParams = params
+        ? params
+            .split(',')
+            .map((p) => `${p.trim()}: any`)
+            .join(', ')
+        : '';
+    return `(${typedParams}) => ${body}`;
+};
+/**
+ * Check if a mock key's schema indicates it should be instantiated as a Map.
+ * A Map is indicated by:
+ * 1. returnValue is an array of tuples (returnValue[][] pattern)
+ * 2. returnValue has Map methods like .get() or .set()
+ */
+const shouldBeMap = (mockKey, mergedDataStructure) => {
+    if (!mergedDataStructure?.dependencySchemas)
+        return false;
+    // Extract entity name from mock key (e.g., "buildUncommittedFileMap()" -> "buildUncommittedFileMap")
+    const entityName = mockKey.split('(')[0];
+    // Search through all dependency schemas
+    for (const [_filePath, entities] of Object.entries(mergedDataStructure.dependencySchemas)) {
+        const entitySchema = entities[entityName];
+        if (!entitySchema?.returnValueSchema)
+            continue;
+        const schema = entitySchema.returnValueSchema;
+        // Check for array-of-tuples pattern
+        const hasArrayOfTuples = schema['returnValue'] === 'array' &&
+            schema['returnValue[]'] === 'array' &&
+            (schema['returnValue[][0]'] === 'string' || schema['returnValue[][0]']);
+        if (!hasArrayOfTuples)
+            continue;
+        // Check for Map methods (.get or .set)
+        const hasMapMethods = Object.keys(schema).some((key) => key.startsWith('returnValue.get(') ||
+            key.startsWith('returnValue.set('));
+        if (hasMapMethods) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Normalize a function call key by stripping arguments but PRESERVING type parameters.
+ * Type parameters like <typeof loader> are important for disambiguation.
+ * Variable qualifiers (::variableName suffix) are also preserved.
+ *
+ * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" -> "useLastLogLine()"
+ * e.g., "useLoaderData<typeof loader>()" -> "useLoaderData<typeof loader>()" (PRESERVED)
+ * e.g., "useFetcher()::entityDiffFetcher" -> "useFetcher()::entityDiffFetcher" (preserved)
+ * e.g., "useFetcher<T>()::entityDiffFetcher" -> "useFetcher<T>()::entityDiffFetcher" (PRESERVED)
+ */
+const normalizeKey = (key) => {
+    // Check for variable qualifier (::variableName)
+    const qualifierMatch = key.match(/::[a-zA-Z_][a-zA-Z0-9_]*$/);
+    const qualifier = qualifierMatch ? qualifierMatch[0] : '';
+    const keyWithoutQualifier = qualifier ? key.slice(0, -qualifier.length) : key;
+    // Check if key ends with ) - indicating a function call (after removing qualifier)
+    if (keyWithoutQualifier.endsWith(')') && keyWithoutQualifier.includes('(')) {
+        // Find the opening paren that matches the closing paren (accounting for nested parens and generics)
+        // We want to strip arguments but preserve type parameters
+        // e.g., "useLoaderData<typeof loader>(arg1, arg2)" -> "useLoaderData<typeof loader>()"
+        // e.g., "foo(a, b)" -> "foo()"
+        // Find where type parameters end (if any) by finding matching < >
+        let typeParamEnd = 0;
+        if (keyWithoutQualifier.includes('<')) {
+            let depth = 0;
+            for (let i = 0; i < keyWithoutQualifier.length; i++) {
+                if (keyWithoutQualifier[i] === '<')
+                    depth++;
+                if (keyWithoutQualifier[i] === '>') {
+                    depth--;
+                    if (depth === 0) {
+                        typeParamEnd = i + 1;
+                        break;
+                    }
+                }
+            }
+        }
+        // Find the opening paren for function arguments (after type params)
+        const argsStart = keyWithoutQualifier.indexOf('(', typeParamEnd);
+        if (argsStart !== -1) {
+            // Preserve everything up to and including the opening paren, then close it
+            const normalized = keyWithoutQualifier.slice(0, argsStart) + '()';
+            return normalized + qualifier;
+        }
+    }
+    return key;
+};
+/**
+ * Extract all keys from a JsonTypeDefinition recursively.
+ * Used to get expected mock data keys from dataForMocks structure.
+ */
+function extractAllKeys(obj) {
+    if (!obj || typeof obj !== 'object')
+        return [];
+    const keys = [];
+    for (const key of Object.keys(obj)) {
+        keys.push(key);
+        const value = obj[key];
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            keys.push(...extractAllKeys(value));
+        }
+    }
+    return keys;
+}
+/**
+ * Bare type markers that indicate a function was detected but has no actual return data.
+ * These should be filtered out of mock data output since they're just type hints.
+ */
+const BARE_TYPE_MARKERS = ['function', 'async-function'];
+/**
+ * Check if a string is a TypeScript arrow function type annotation rather than
+ * a valid JavaScript arrow function expression.
+ *
+ * TypeScript arrow types look like function expressions (they contain '=>') but
+ * their "body" is a type name, not a JS expression:
+ * - "() => void"
+ * - "(event: MouseEvent) => void"
+ * - "() => string"
+ * - "() => Promise<void>"
+ * - "(id: string, name: string) => boolean"
+ *
+ * Valid JS arrow functions have actual expression bodies:
+ * - "() => {}"
+ * - "() => 'hello'"
+ * - "(x) => x + 1"
+ * - "() => { console.log('hi'); }"
+ */
+const ARROW_TYPE_RETURN_TYPES = /^(void|string|number|boolean|any|unknown|never|null|undefined|object|Date|Promise<\w+>)$/i;
+const isArrowFunctionTypeAnnotation = (value) => {
+    const arrowIndex = value.indexOf('=>');
+    if (arrowIndex === -1)
+        return false;
+    const body = value.slice(arrowIndex + 2).trim();
+    // A real JS function would have {}, an expression, a string literal, etc.
+    // A type annotation has a bare type keyword as the "body".
+    return ARROW_TYPE_RETURN_TYPES.test(body);
+};
+/**
+ * Check if a value is a bare function type marker that should be filtered out.
+ * These markers indicate the LLM detected a function but couldn't generate meaningful mock data.
+ *
+ * Also catches TypeScript union types containing function, like:
+ * - "function | null"
+ * - "function | undefined"
+ * - "async-function | null"
+ */
+const isBareTypeMarker = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    // Check for exact bare type markers
+    if (BARE_TYPE_MARKERS.includes(value))
+        return true;
+    // Check for TypeScript union types containing function type markers
+    // e.g., "function | null", "function | undefined", "async-function | null"
+    if (value.includes('|')) {
+        const parts = value.split('|').map((p) => p.trim());
+        // If any part is a bare type marker, treat the whole thing as a type marker
+        return parts.some((part) => BARE_TYPE_MARKERS.includes(part));
+    }
+    return false;
+};
+/**
+ * Escape newlines that appear inside string literals within a code string,
+ * while preserving structural newlines (those between statements/lines of code).
+ *
+ * This handles cases where LLM generates function bodies like:
+ * - "() => { console.log('line1\nline2'); }" - escape the \n inside the string
+ * - "() => {\n  console.log('x');\n}" - preserve structural \n between statements
+ * - "() => Promise.resolve('a\nb')" - escape the \n inside the string argument
+ *
+ * The algorithm tracks whether we're inside a string literal (single, double, or
+ * backtick quotes) and only escapes newlines that appear within quotes.
+ */
+const escapeNewlinesInStringLiterals = (code) => {
+    let result = '';
+    let inString = false;
+    let stringChar = ''; // The quote character that started the current string
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        const prevChar = i > 0 ? code[i - 1] : '';
+        // Check for string literal boundaries (single, double, or backtick quotes)
+        // Skip escaped quotes (preceded by backslash)
+        if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+            if (!inString) {
+                // Starting a string literal
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                // Ending the current string literal
+                inString = false;
+                stringChar = '';
+            }
+            // If char is a different quote type while in a string, it's just a character
+        }
+        // Escape newlines only when inside a string literal
+        if (char === '\n') {
+            if (inString) {
+                // Inside a string literal - escape the newline
+                result += '\\n';
+            }
+            else {
+                // Outside string - keep the structural newline
+                result += char;
+            }
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+};
+/**
+ * Normalize mock data by merging entries that have the same normalized function name.
+ * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" and
+ *       "useLastLogLine(projectSlug, currentRunActive)" both become "useLastLogLine()"
+ * Their values are deep-merged to ensure all attributes are accounted for.
+ *
+ * Also filters out bare function type markers like "validateInputs()": "function"
+ * which are just type hints without actual mock data.
+ */
+const normalizeMockData = (mockData) => {
+    const normalized = {};
+    const keyMapping = new Map();
+    // First pass: group keys by their normalized form
+    for (const key of Object.keys(mockData)) {
+        const normKey = normalizeKey(key);
+        if (!keyMapping.has(normKey)) {
+            keyMapping.set(normKey, []);
+        }
+        keyMapping.get(normKey).push(key);
+    }
+    // Helper to check if a value is an empty object
+    const isEmptyObject = (value) => {
+        return (value !== null &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0);
+    };
+    // Second pass: merge values for duplicate normalized keys
+    for (const [normKey, originalKeys] of keyMapping) {
+        if (originalKeys.length === 1) {
+            // No duplicates - PRESERVE the original key with arguments
+            // This is critical because constructMockCode generates code that accesses
+            // data with the FULL key (e.g., scenarios().data()?.["useCustomSizes(projectSlug)"])
+            // If we normalize to "useCustomSizes()" but code looks for "useCustomSizes(projectSlug)",
+            // the lookup fails and returns undefined, causing runtime errors.
+            const value = mockData[originalKeys[0]];
+            // Skip bare type markers like "function" or "async-function"
+            if (isBareTypeMarker(value)) {
+                continue;
+            }
+            // Skip empty objects - these cause "Objects are not valid as a React child" errors
+            // when mock functions return them (e.g., CheckCircle2() from lucide-react)
+            if (isEmptyObject(value)) {
+                continue;
+            }
+            normalized[originalKeys[0]] = value;
+        }
+        else {
+            // Multiple keys normalize to the same value - merge them
+            let mergedValue = {};
+            for (const origKey of originalKeys) {
+                const value = mockData[origKey];
+                // Skip bare type markers when merging
+                if (isBareTypeMarker(value)) {
+                    continue;
+                }
+                if (value &&
+                    typeof value === 'object' &&
+                    !Array.isArray(value) &&
+                    mergedValue &&
+                    typeof mergedValue === 'object' &&
+                    !Array.isArray(mergedValue)) {
+                    mergedValue = deepMerge(mergedValue, value);
+                }
+                else {
+                    // For non-objects or arrays, later values take precedence
+                    mergedValue = value;
+                }
+            }
+            // Only add if we have actual data (not just filtered type markers)
+            // Note: typeof null === 'object' in JS, so we must check for null explicitly
+            if (mergedValue !== undefined &&
+                !isBareTypeMarker(mergedValue) &&
+                !(mergedValue !== null &&
+                    typeof mergedValue === 'object' &&
+                    Object.keys(mergedValue).length === 0)) {
+                normalized[normKey] = mergedValue;
+            }
+        }
+    }
+    return normalized;
+};
+const jsonToCode = (json, level = 1, mergedDataStructure, currentKey) => {
+    if (!json)
+        return '';
+    try {
+        let dataString = '';
+        const levelSpacing = getLevelSpacing(level);
+        if (Array.isArray(json)) {
+            const arrayStrings = [];
+            for (const item of json) {
+                // Skip undefined but preserve null (important for ref props)
+                if (item === undefined)
+                    continue;
+                if (item === null) {
+                    arrayStrings.push('null');
+                }
+                else if (typeof item === 'object') {
+                    arrayStrings.push(jsonToCode(item, level + 1, mergedDataStructure));
+                }
+                else {
+                    arrayStrings.push(`"${safeString(item, level)}"`);
+                }
+            }
+            return `[\n${levelSpacing}${arrayStrings.join(`,\n${levelSpacing}`)}\n${getLevelSpacing(level - 1)}]`;
+        }
+        else {
+            const keyStrings = [];
+            const jsonObj = json;
+            // Track normalized function names to avoid duplicate keys in output
+            // e.g., submit({ a }) and submit({ b }) should both become "submit" once
+            const seenNormalizedFuncNames = new Set();
+            // Pre-scan to identify plain keys that have function-call versions
+            // These plain keys should be skipped because the function-call version
+            // will be normalized to the same key name
+            // e.g., if both "push" and "push(`/path`)" exist, skip the plain "push"
+            const plainKeysWithFunctionCallVersions = new Set();
+            for (const key of Object.keys(jsonObj)) {
+                if (key.includes('(') && key.endsWith(')')) {
+                    const funcName = key.split('(')[0];
+                    // Check if a plain key with this name exists
+                    if (funcName in jsonObj && !funcName.includes('(')) {
+                        plainKeysWithFunctionCallVersions.add(funcName);
+                    }
+                }
+            }
+            for (const key of Object.keys(jsonObj)) {
+                if (jsonObj[key] === undefined)
+                    continue;
+                // Preserve explicit null values - components check `value !== null`
+                // to distinguish "not loaded" (undefined) from "explicitly null"
+                if (jsonObj[key] === null) {
+                    keyStrings.push(`${levelSpacing}"${safeString(key, level)}": null`);
+                    continue;
+                }
+                if (Array.isArray(jsonObj[key])) {
+                    if (key === '~~codeyam-jsx~~') {
+                        return `<>${jsonObj[key].join('')}</>`;
+                    }
+                    // Check if this is a nested function signature with array value
+                    // e.g., "postMessage(message, '*')": ["mockMessageString", "*"]
+                    // These need to be transformed into callable arrow functions
+                    // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+                    // (level 2) are return values that should preserve their data
+                    // Skip when array contains objects (likely return data like getAll() returning [{name, value}])
+                    const argsArray = jsonObj[key];
+                    const isReturnData = argsArray.some((item) => item && typeof item === 'object' && !Array.isArray(item));
+                    if (key.includes('(') &&
+                        key.endsWith(')') &&
+                        level > 2 &&
+                        !isReturnData) {
+                        const funcName = key.split('(')[0];
+                        // Skip if we've already added this normalized function name
+                        if (seenNormalizedFuncNames.has(funcName)) {
+                            continue;
+                        }
+                        seenNormalizedFuncNames.add(funcName);
+                        const argsArray = jsonObj[key];
+                        const argsString = argsArray
+                            .map((_, i) => `arg${i + 1}`)
+                            .join(', ');
+                        console.log(`CodeYam: Nested func transform (array): "${key}" -> "${funcName}"`);
+                        keyStrings.push(`${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`);
+                        continue;
+                    }
+                    const arrayString = jsonToCode(jsonObj[key], level + 1, mergedDataStructure);
+                    // Check if this key should be instantiated as a Map
+                    if (mergedDataStructure && shouldBeMap(key, mergedDataStructure)) {
+                        keyStrings.push(`${levelSpacing}"${safeString(key, level)}": new Map(${arrayString})`);
+                    }
+                    else {
+                        keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${arrayString}`);
+                    }
+                }
+                else if (jsonObj[key] !== null && typeof jsonObj[key] === 'object') {
+                    const objKeys = Object.keys(jsonObj[key]);
+                    // Check if this is a nested function signature (e.g., "postMessage(message, targetOrigin)": { signature: [...] })
+                    // These need to be transformed into callable arrow functions
+                    // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+                    // (level 2) are return values that should preserve their data
+                    if (key.includes('(') &&
+                        key.endsWith(')') &&
+                        level > 2 &&
+                        objKeys.includes('signature') &&
+                        Array.isArray(jsonObj[key].signature)) {
+                        const funcName = key.split('(')[0];
+                        // Skip if we've already added this normalized function name
+                        if (seenNormalizedFuncNames.has(funcName)) {
+                            continue;
+                        }
+                        seenNormalizedFuncNames.add(funcName);
+                        const signature = jsonObj[key]
+                            .signature;
+                        const argsString = signature
+                            .map((_, i) => `arg${i + 1}`)
+                            .join(', ');
+                        console.log(`CodeYam: Nested func transform (signature): "${key}" -> "${funcName}"`);
+                        keyStrings.push(`${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`);
+                    }
+                    else if (
+                    // Check if this object has a "functionCallReturnValue" key - if so, unwrap it
+                    objKeys.length === 1 &&
+                        objKeys[0] === 'functionCallReturnValue') {
+                        const unwrappedValue = jsonObj[key]
+                            .functionCallReturnValue;
+                        if (typeof unwrappedValue === 'string') {
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": "${safeString(unwrappedValue, level)}"`);
+                        }
+                        else if (typeof unwrappedValue === 'object') {
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${jsonToCode(unwrappedValue, level + 1, mergedDataStructure)}`);
+                        }
+                        else {
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${safeString(String(unwrappedValue), level)}`);
+                        }
+                    }
+                    else if (
+                    // Check if this object has a function signature key like "(entity.sha)" - flatten it
+                    objKeys.length === 1 &&
+                        objKeys[0].startsWith('(') &&
+                        objKeys[0].endsWith(')')) {
+                        const signatureKey = objKeys[0];
+                        // Extract arguments without parentheses for the function name
+                        const args = signatureKey.slice(1, -1);
+                        const unwrappedValue = jsonObj[key][signatureKey];
+                        // Handle null values - generate arrow function stubs for function signatures with null
+                        if (unwrappedValue === null) {
+                            const funcName = key;
+                            const argsString = args
+                                .split(',')
+                                .map((arg, i) => `${arg.trim()}: any`)
+                                .join(', ');
+                            keyStrings.push(`${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`);
+                        }
+                        else if (typeof unwrappedValue === 'string') {
+                            const flattenedKey = `${key}(${args})`;
+                            keyStrings.push(`${levelSpacing}"${safeString(flattenedKey, level)}": "${safeString(unwrappedValue, level)}"`);
+                        }
+                        else if (typeof unwrappedValue === 'object') {
+                            const flattenedKey = `${key}(${args})`;
+                            keyStrings.push(`${levelSpacing}"${safeString(flattenedKey, level)}": ${jsonToCode(unwrappedValue, level + 1, mergedDataStructure)}`);
+                        }
+                        else if (typeof unwrappedValue === 'boolean') {
+                            const flattenedKey = `${key}(${args})`;
+                            keyStrings.push(`${levelSpacing}"${safeString(flattenedKey, level)}": ${unwrappedValue}`);
+                        }
+                        else {
+                            const flattenedKey = `${key}(${args})`;
+                            keyStrings.push(`${levelSpacing}"${safeString(flattenedKey, level)}": ${safeString(String(unwrappedValue), level)}`);
+                        }
+                    }
+                    else {
+                        // Skip plain keys that have function-call versions (at deeper nesting levels)
+                        // e.g., if both "t" and "t('common.close')" exist, skip the plain "t" object
+                        // because the function-call version will be normalized to "t"
+                        if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+                            console.log(`CodeYam: Skipping plain object key "${key}" (has function-call version that will be normalized)`);
+                            continue;
+                        }
+                        keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${jsonToCode(jsonObj[key], level + 1, mergedDataStructure)}`);
+                    }
+                }
+                else if (key === '~~codeyam-code~~' || key === '~~codeyam-jsx~~') {
+                    const keyValue = jsonObj[key];
+                    if (keyValue.indexOf('new Date()') === 0) {
+                        return `(${keyValue}).toString()`;
+                    }
+                    if (keyValue.indexOf('function') === 0) {
+                        return `{}`;
+                    }
+                    if (key === '~~codeyam-jsx~~') {
+                        if (needsFragment(keyValue)) {
+                            return `<>${keyValue}</>`;
+                        }
+                        return keyValue;
+                    }
+                    return keyValue;
+                }
+                else if (typeof jsonObj[key] === 'string') {
+                    const stringValue = jsonObj[key];
+                    // Check if this is a nested function signature with string value
+                    // e.g., "postMessage(message, '*')": "() => { console.log('postMessage called'); }"
+                    // These need to have the key normalized to just the function name
+                    // Only apply at deeper nesting levels (level > 2)
+                    if (key.includes('(') && key.endsWith(')') && level > 2) {
+                        const funcName = key.split('(')[0];
+                        // Extract the function arguments to check if they're string literals
+                        const argsMatch = key.match(/\((.+)\)$/);
+                        const args = argsMatch ? argsMatch[1].trim() : '';
+                        // Check if the argument is a simple string literal like "common.close" or 'common.close'
+                        // These are static lookup keys (e.g., translation functions) and should NOT be normalized
+                        const isStringLiteralArg = /^["'][^"']*["']$/.test(args);
+                        if (isStringLiteralArg) {
+                            // DON'T normalize - preserve the full key for static lookups (e.g., translations)
+                            // This allows constructMockCode to generate a dispatch function that looks up by key
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`);
+                            console.log(`CodeYam: Preserving string-literal function key for lookup: "${key}": "${stringValue}"`);
+                            continue;
+                        }
+                        // Skip if we've already added this normalized function name
+                        if (seenNormalizedFuncNames.has(funcName)) {
+                            continue;
+                        }
+                        // Skip TypeScript union type markers like "function | null" - these are type hints
+                        // that would produce invalid JavaScript if output as-is.
+                        // Note: We only skip UNION types here (containing '|'), not bare 'function'
+                        // because bare 'function' is transformed to () => {} below.
+                        // Note: This must come BEFORE seenNormalizedFuncNames.add() so that
+                        // if another key with the same funcName has actual data, it can be used.
+                        if (stringValue.includes('|') && isBareTypeMarker(stringValue)) {
+                            continue;
+                        }
+                        seenNormalizedFuncNames.add(funcName);
+                        // Check if the string value looks like a function expression
+                        // Be careful not to match descriptive strings like "function listening" -
+                        // a valid function expression must have parentheses like function(), function name(), or function (
+                        const looksLikeFunction = stringValue.includes('=>') ||
+                            /^function\s*[\w]*\s*\(/.test(stringValue) ||
+                            /^async\s+function\s*[\w]*\s*\(/.test(stringValue) ||
+                            /^async\s*\(/.test(stringValue);
+                        // Check if the string value looks like a Promise expression
+                        // e.g., "Promise.resolve()", "new Promise(...)", etc.
+                        const looksLikePromise = stringValue.startsWith('Promise.') ||
+                            stringValue.startsWith('new Promise');
+                        // Check if the string contains newlines (potential issue for string literals)
+                        const hasNewlines = stringValue.includes('\n');
+                        // Handle special type indicators that need transformation
+                        let outputValue;
+                        if (stringValue === 'promise' || looksLikePromise) {
+                            // The key is a function call (e.g., "revalidate()"), so output a function
+                            // that returns a Promise, not the Promise itself
+                            // Important: Escape newlines inside Promise expressions to avoid
+                            // "unterminated string literal" errors when the Promise contains
+                            // multi-line string arguments like Promise.resolve('line1\nline2')
+                            const promiseExpr = looksLikePromise
+                                ? stringValue.replace(/\n/g, '\\n')
+                                : 'Promise.resolve()';
+                            outputValue = `() => ${promiseExpr}`;
+                            console.log(`CodeYam: Nested func transform (string->Promise): "${key}" -> "${funcName}": () => ${promiseExpr}`);
+                        }
+                        else if (stringValue === 'function') {
+                            outputValue = '() => {}';
+                            console.log(`CodeYam: Nested func transform (string->function): "${key}" -> "${funcName}": () => {}`);
+                        }
+                        else if (looksLikeFunction) {
+                            // Check for "[native code]" in function body — this is what
+                            // Function.prototype.toString() returns for built-in functions.
+                            // The LLM sometimes generates "function () { [native code] }" which
+                            // is not valid JavaScript (the "[" is parsed as array destructuring).
+                            if (stringValue.includes('[native code]')) {
+                                outputValue = '() => {}';
+                                console.log(`CodeYam: Nested func transform (native-code->noop): "${key}" -> "${funcName}": () => {}`);
+                            }
+                            else if (cleanMalformedFunctionValue(stringValue)) {
+                                // Check for malformed LLM-generated function values like "(function)() => {}"
+                                // These have an invalid "(function)" prefix that must be stripped
+                                outputValue = cleanMalformedFunctionValue(stringValue);
+                                console.log(`CodeYam: Nested func transform (malformed->clean): "${key}" -> "${funcName}": ${outputValue}`);
+                            }
+                            else if (isArrowFunctionTypeAnnotation(stringValue)) {
+                                // TypeScript arrow function type annotations like "() => void",
+                                // "(event: MouseEvent) => void", "() => Promise<void>" contain '=>'
+                                // so they pass the looksLikeFunction check, but they are TYPE syntax,
+                                // not valid JavaScript expressions. Convert to a no-op function.
+                                outputValue = '() => {}';
+                                console.log(`CodeYam: Nested func transform (type-annotation->function): "${key}" -> "${funcName}": () => {}`);
+                            }
+                            else {
+                                // Handle newlines in function expressions:
+                                // - Newlines inside string literals must be escaped to avoid
+                                //   "unterminated string literal" errors
+                                // - Structural newlines (between statements) should be kept as-is
+                                //   to produce valid multi-line JavaScript
+                                //
+                                // We escape ONLY newlines that appear inside string literals (single,
+                                // double, or template quotes). Structural newlines are preserved.
+                                if (hasNewlines) {
+                                    outputValue = escapeNewlinesInStringLiterals(stringValue);
+                                }
+                                else {
+                                    outputValue = stringValue;
+                                }
+                                console.log(`CodeYam: Nested func transform (string): "${key}" -> "${funcName}": ${stringValue.substring(0, 30)}...`);
+                            }
+                        }
+                        else {
+                            // Plain string value - must be quoted
+                            outputValue = `"${safeString(stringValue, level)}"`;
+                            console.log(`CodeYam: Nested func transform (string->quoted): "${key}" -> "${funcName}": "${stringValue}"`);
+                        }
+                        keyStrings.push(`${levelSpacing}"${safeString(funcName, level)}": ${outputValue}`);
+                    }
+                    else {
+                        // Skip plain keys that have function-call versions (at the same nesting level where
+                        // function-call keys get normalized). The function-call version will be output instead.
+                        // e.g., if both "push" and "push(`/path`)" exist, skip "push" - the other normalizes to "push"
+                        if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+                            console.log(`CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`);
+                            continue;
+                        }
+                        // Skip bare type markers like "function", "function | null", etc.
+                        // For plain keys (not function signatures), these are just type hints
+                        // that would produce invalid JavaScript if output as-is.
+                        if (isBareTypeMarker(stringValue)) {
+                            continue;
+                        }
+                        // Check for malformed LLM-generated function values like "(function)(id) => {}"
+                        // These can appear on plain keys (e.g., "closeToast") and need to be output as
+                        // actual functions, not quoted strings
+                        const cleanedPlainKeyFn = cleanMalformedFunctionValue(stringValue);
+                        if (cleanedPlainKeyFn) {
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${cleanedPlainKeyFn}`);
+                            console.log(`CodeYam: Plain key func transform (malformed->clean): "${key}": ${cleanedPlainKeyFn}`);
+                        }
+                        else {
+                            keyStrings.push(`${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`);
+                        }
+                    }
+                }
+                else {
+                    // Skip plain keys that have function-call versions (at the same nesting level where
+                    // function-call keys get normalized)
+                    if (level > 2 && plainKeysWithFunctionCallVersions.has(key)) {
+                        console.log(`CodeYam: Skipping plain key "${key}" (has function-call version that will be normalized)`);
+                        continue;
+                    }
+                    keyStrings.push(`${levelSpacing}"${safeString(key, level)}": ${safeString(String(jsonObj[key]), level)}`);
+                }
+            }
+            const outerLevelSpacing = getLevelSpacing(level - 1);
+            dataString = `{\n${keyStrings.join(',\n')}\n${outerLevelSpacing}}`;
+            return dataString;
+        }
+    }
+    catch (e) {
+        console.log('CodeYam: Error converting JSON to code', json, level);
+        throw e;
+    }
+};
+export default async function writeMockDataTsx(analysis, mockScenario, mockDataPath) {
+    const { file, scenarios, metadata } = analysis;
+    if (!scenarios) {
+        console.log(`🚫 No mock data for scenarios found for ${file.path} ${analysis.entityName} ${analysis.id}`);
+        return;
+    }
+    const defaultScenario = scenarios.find((mockScenario) => mockScenario.name === DEFAULT_SCENARIO_NAME);
+    if (!defaultScenario) {
+        console.log(`CodeYam Warning: No default scenario found ${file.path} ${analysis.entityName} ${analysis.id}`);
+    }
+    let argumentsData = defaultScenario?.metadata?.data?.argumentsData ?? [];
+    if (!Array.isArray(argumentsData)) {
+        argumentsData = [];
+    }
+    const defaultArguments = [...argumentsData];
+    const rawDefaultMockData = {
+        ...(defaultScenario?.metadata?.data?.mockData ?? {}),
+    };
+    // Get expected keys from dataForMocks structure (which preserves variable references)
+    const dataForMocks = metadata?.scenariosDataStructure?.dataForMocks;
+    const expectedKeys = extractAllKeys(dataForMocks);
+    // Reconcile mock data keys to match expected keys from dataForMocks
+    // This handles cases where LLM generated literal values instead of variable references
+    const reconciledMockData = reconcileMockDataKeys(rawDefaultMockData, expectedKeys);
+    // Convert comma-separated strings to arrays for fields that should be arrays
+    // This handles cases where LLM generates "color,size" instead of ["color", "size"]
+    const defaultMockData = convertCommaSeparatedStringsToArrays(reconciledMockData);
+    const mockDataComment = `// This file is auto-generated by CodeYam. Do not edit this file manually.
+// This file contains mock data required for:
+// Scenario: ${mockScenario.id} - ${mockScenario.name}
+// Analysis: ${analysis.id}
+// Entity: ${analysis.entitySha} ${analysis.entityName}
+// File: ${file.id} - ${file.path}
+
+import React from 'react';
+`;
+    let mockDataCode = `${mockDataComment}\n`;
+    let dataCode;
+    const mergedDataStructure = metadata?.mergedDataStructure;
+    if (mockScenario.name === DEFAULT_SCENARIO_NAME) {
+        // Normalize mock data to merge entries with same normalized function name
+        const normalizedMockData = normalizeMockData(defaultMockData);
+        // Fix useParams splat param (*) to default to empty string
+        const paramsNormalizedMockData = normalizeParamsMockData(normalizedMockData);
+        dataCode = jsonToCode({
+            arguments: defaultArguments,
+            ...paramsNormalizedMockData,
+        }, 2, mergedDataStructure);
+    }
+    else {
+        const scenarioArguments = [
+            ...(mockScenario.metadata.data?.argumentsData ?? []),
+        ];
+        const rawScenarioMockData = {
+            ...(mockScenario.metadata.data?.mockData ?? {}),
+        };
+        // Reconcile scenario-specific mock data keys as well
+        const reconciledScenarioMockData = reconcileMockDataKeys(rawScenarioMockData, expectedKeys);
+        // Convert comma-separated strings to arrays for scenario data
+        const scenarioMockData = convertCommaSeparatedStringsToArrays(reconciledScenarioMockData);
+        const mergedArguments = defaultArguments.map((defaultArg, index) => {
+            return deepMerge(defaultArg, scenarioArguments[index]);
+        });
+        const mergedMockData = deepMerge(defaultMockData, scenarioMockData);
+        // Normalize mock data to merge entries with same normalized function name
+        const normalizedMockData = normalizeMockData(mergedMockData);
+        // Fix useParams splat param (*) to default to empty string
+        const paramsNormalizedMockData = normalizeParamsMockData(normalizedMockData);
+        const mergedData = {
+            arguments: mergedArguments,
+            ...paramsNormalizedMockData,
+        };
+        // Use level=2 (same as default scenario) for consistent key formatting.
+        // This ensures nested function arguments are kept (e.g., "from('workouts')")
+        // to match constructMockCode's data path generation.
+        dataCode = jsonToCode(mergedData, 2, mergedDataStructure);
+    }
+    mockDataCode += `const scenariosData = ${dataCode};`;
+    mockDataCode += `\n\n${processingFunction}`;
+    // Generate scenario-specific filename to allow multiple scenarios to coexist
+    const scenarioFileName = `MockData_${safeFileName(mockScenario.name)}.tsx`;
+    const mockDataTsxPath = path.join(mockDataPath, scenarioFileName);
+    await writeFile(mockDataTsxPath, mockDataCode);
+    console.log('CodeYam: Data Complete', { scenarioFileName });
+    return mockDataTsxPath;
+}
+const processingFunction = `declare global {
+    interface Window { codeyam: { inMemoryData: unknown }; }
+}
+
+// Special type markers for serialization
+const TYPE_MARKERS = {
+    FUNCTION: '__FUNCTION__',
+    DATE: '__DATE__',
+    REGEXP: '__REGEXP__',
+    UNDEFINED: '__UNDEFINED__',
+    BIGINT: '__BIGINT__',
+    MAP: '__MAP__',
+    SET: '__SET__',
+    ERROR: '__ERROR__',
+    SYMBOL: '__SYMBOL__',
+    ARROW_FUNCTION: '__ARROW_FUNCTION__',
+    REACT_ELEMENT: '__REACT_ELEMENT__'  // New marker for React elements
+};
+
+function serialize(obj) {
+    return JSON.stringify(obj, (key, value) => {
+        // Handle undefined
+        if (value === undefined) {
+            return { __type: TYPE_MARKERS.UNDEFINED };
+        }
+        
+        // Handle React elements
+        if (value && typeof value === 'object' && 
+            (value.$$typeof === Symbol.for('react.element') || 
+             (value.type && value.props && 'children' in value.props))) {
+            return {
+                __type: TYPE_MARKERS.REACT_ELEMENT,
+                type: typeof value.type === 'function' ? value.type.name : value.type,
+                props: {...value.props},
+                key: value.key || null
+            };
+        }
+        
+        // Handle functions
+        if (typeof value === 'function') {
+            let fnStr;
+            try {
+                fnStr = value.toString();
+            } catch (toStringErr) {
+                console.warn('CodeYam: Function.toString() threw error:', toStringErr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
+            // Defensive check: ensure fnStr is actually a string
+            if (typeof fnStr !== 'string') {
+                console.warn('CodeYam: Function.toString() returned non-string:', typeof fnStr, fnStr, 'function name:', value.name);
+                return {
+                    __type: TYPE_MARKERS.FUNCTION,
+                    value: '() => {}',
+                    name: value.name || 'anonymous'
+                };
+            }
+
+            // Check if it's an arrow function
+            if (fnStr.includes('=>')) {
+                const arrowIndex = fnStr.indexOf('=>');
+                // Extra safety: verify indexOf returned a valid index
+                if (arrowIndex === -1) {
+                    console.warn('CodeYam: Arrow function detection inconsistency - includes found => but indexOf returned -1. fnStr:', fnStr);
+                    return {
+                        __type: TYPE_MARKERS.FUNCTION,
+                        value: fnStr,
+                        name: value.name
+                    };
+                }
+                return {
+                    __type: TYPE_MARKERS.ARROW_FUNCTION,
+                    params: fnStr.substring(0, arrowIndex).trim(),
+                    body: fnStr.substring(arrowIndex + 2).trim()
+                };
+            }
+            return {
+                __type: TYPE_MARKERS.FUNCTION,
+                value: fnStr,
+                name: value.name
+            };
+        }
+        
+        // Handle Dates
+        if (value instanceof Date) {
+            return {
+                __type: TYPE_MARKERS.DATE,
+                value: value.getTime()
+            };
+        }
+        
+        // Handle RegExp
+        if (value instanceof RegExp) {
+            return {
+                __type: TYPE_MARKERS.REGEXP,
+                source: value.source,
+                flags: value.flags
+            };
+        }
+        
+        // Handle BigInt
+        if (typeof value === 'bigint') {
+            return {
+                __type: TYPE_MARKERS.BIGINT,
+                value: value.toString()
+            };
+        }
+        
+        // Handle Map
+        if (value instanceof Map) {
+            return {
+                __type: TYPE_MARKERS.MAP,
+                value: Array.from(value.entries())
+            };
+        }
+        
+        // Handle Set
+        if (value instanceof Set) {
+            return {
+                __type: TYPE_MARKERS.SET,
+                value: Array.from(value.values())
+            };
+        }
+        
+        // Handle Error objects
+        if (value instanceof Error) {
+            return {
+                __type: TYPE_MARKERS.ERROR,
+                name: value.name,
+                message: value.message,
+                stack: value.stack
+            };
+        }
+        
+        // Handle Symbols
+        if (typeof value === 'symbol') {
+            return {
+                __type: TYPE_MARKERS.SYMBOL,
+                description: value.description
+            };
+        }
+        
+        return value;
+    });
+}
+
+function deserialize(jsonString) {    
+    return JSON.parse(jsonString, (key, value) => {
+        if (value === null || typeof value !== 'object' || !value.__type) {
+            return value;
+        }
+        
+        switch (value.__type) {
+            case TYPE_MARKERS.REACT_ELEMENT:
+                // Handle React elements
+                let { type, props, key } = value;
+                // If type is a string (like 'div'), use it directly
+                // For component names, you might need to map them to actual components
+                let stringType = String(type);
+                if (stringType.startsWith('Symbol(react.')) {
+                    stringType = stringType.replace(/Symbol\\(([^)]+)\\)/, '$1')
+                    type = Symbol.for(stringType);
+                }
+                return React.createElement(type, { ...props, key });
+                
+            case TYPE_MARKERS.FUNCTION:
+                try {
+                    // Handle named functions - extract params and body properly
+                    if (value.name && value.name !== 'anonymous') {
+                        const parenStart = value.value.indexOf('(');
+                        const braceStart = value.value.indexOf('{');
+                        if (parenStart !== -1 && braceStart !== -1 && parenStart < braceStart) {
+                            // Extract params (between first ( and the { that starts the body)
+                            const params = value.value.slice(parenStart, braceStart).trim();
+                            const functionBody = value.value.slice(braceStart + 1, value.value.lastIndexOf('}'));
+                            return new Function(\`return function \${value.name}\${params}{\${functionBody}}\`)();
+                        }
+                    }
+                    // Handle anonymous functions or fallback
+                    return new Function(\`return \${value.value}\`)();
+                } catch (e) {
+                    console.warn('Error deserializing function:', e);
+                    return function() {
+                        return 'Error: Function could not be deserialized';
+                    };
+                }
+                
+            case TYPE_MARKERS.ARROW_FUNCTION:
+                try {
+                    // Convert arrow function to regular function
+                    const params = value.params.replace(/[()s]/g, '').split(',').filter(Boolean);
+                    const body = value.body.startsWith('{') 
+                        ? value.body.slice(1, -1) // If body has curly braces, remove them
+                        : \`return \${value.body}\`; // If body is an expression, add return
+                    return new Function(...params, body);
+                } catch (e) {
+                    console.warn('Error deserializing arrow function:', e);
+                    return function() { 
+                        return 'Error: Arrow function could not be deserialized'; 
+                    };
+                }
+                
+            case TYPE_MARKERS.DATE:
+                return new Date(value.value);
+                
+            case TYPE_MARKERS.REGEXP:
+                return new RegExp(value.source, value.flags);
+                
+            case TYPE_MARKERS.UNDEFINED:
+                return undefined;
+                
+            case TYPE_MARKERS.BIGINT:
+                return BigInt(value.value);
+                
+            case TYPE_MARKERS.MAP:
+                return new Map(value.value);
+                
+            case TYPE_MARKERS.SET:
+                return new Set(value.value);
+                
+            case TYPE_MARKERS.ERROR:
+                const error = new Error(value.message);
+                error.name = value.name;
+                error.stack = value.stack;
+                return error;
+                
+            case TYPE_MARKERS.SYMBOL:
+                return Symbol(value.description);
+                
+            default:
+                return value;
+        }
+    });
+}
+
+export const scenarios = () => {
+    if (typeof window !== "undefined") {
+        if (!window.codeyam?.inMemoryData) {
+            window.codeyam = {
+                inMemoryData: {
+                    ...scenariosData,
+                    version: Math.random()
+                }
+            };
+        }
+    };
+
+
+    const processData = (scenarioName, data, path = []) => {
+        const processedData = data;
+       
+        if (typeof data === "object") {
+            for (const item in data) {
+                if (item === "~~codeyam-code~~") {
+                    if (data[item].indexOf('new Date()') === 0) {
+                        try {
+                            return eval(\`(\${data[item]}).toString()\`);
+                        } catch (e) {
+                            console.log("Error parsing codeyam-code date", data[item]);
+                            console.log("Error parsing codeyam-code date", e);
+                        }
+                    }
+
+                    try {
+                        return eval(data[item]);
+                    } catch (e) {
+                        console.log("Error parsing codeyam-code", data[item]);
+                        console.log("Error parsing codeyam-code", e);
+                    }
+                } else if (item === "~~codeyam-jsx~~") {
+                    let originalData = scenariosData[scenarioName];
+                    for (const pathItem of path) {
+                        originalData = originalData[pathItem];
+                    }
+                    // could try this: https://www.npmjs.com/package/react-html-parser
+                    return originalData;
+                }
+                path.push(item)
+                processedData[item] = processData(scenarioName, data[item], path);
+            }
+        }
+
+        if (Array.isArray(data)) {
+            for (let i=0; i<data.length; ++i) {
+                path.push(i);
+                processedData[i] = processData(scenarioName, data[i], path);
+            }
+        }
+
+        return processedData
+    }
+
+    return {
+        data: () => {
+            if (typeof window === "undefined") {
+                return deserialize(serialize(scenariosData));
+            }
+            if (!window.codeyam?.inMemoryData) {
+                window.codeyam = {
+                    inMemoryData: deserialize(serialize(scenariosData))
+                };
+            }
+            return window.codeyam.inMemoryData;
+        },
+        updateData: (scenarioName, newData) => {
+            window.codeyam.inMemoryData = processData(scenarioName, newData);
+        }
+    }
+}`;
+//# sourceMappingURL=writeMockDataTsx.js.map