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

package/src/app.generator.js

@@ -0,0 +1,1272 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const execa_1 = __importDefault(require("execa"));
+const path_2 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const transpile_1 = require("./transpile/transpile");
+const grouping_util_1 = require("./utils/grouping-util");
+const variable_transformer_1 = __importDefault(require("./variables/variable.transformer"));
+const utils_1 = require("./utils");
+const bind_ex_transformer_1 = __importDefault(require("./transpile/bind.ex.transformer"));
+const profile_1 = __importDefault(require("./profiles/profile"));
+const utils_2 = require("./utils");
+const gen_app_override_css_1 = require("./gen-app-override-css");
+const wmx_generator_1 = require("./wmx.generator");
+const COMPONENT_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/component.hbs");
+const COMPONENT_PAGE_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/page.hbs");
+const PARTIAL_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/partial.hbs");
+const COMPONENT_PROPS_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/component.props.template");
+const SCRIPT_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/script.template");
+const PAGE_CONFIG_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/pages-config.template");
+const PARTIAL_CONFIG_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/partial-config.template");
+const VARIABLE_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/variables.template");
+const ENTITY_PROVIDER_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/entity-provider.template");
+const APP_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/app.template.hbs");
+const APP_SCRIPT_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/app.script.hbs");
+const FORMATTERS_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/formatter.hbs");
+const APP_LIBS_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/app.libs.hbs");
+const LAYOUT_TEMPLATE = (0, utils_1.loadTemplate)(__dirname + "/../templates/component/layout.hbs");
+const ALL_GENERATED_FILES = "(src/**/*.js|App.js|app.style.js|bootstrap.js|app/**/*.js|wm-project-properties.ts)";
+// REF: https://github.com/facebook/metro/blob/master/packages/metro-config/src/defaults/defaults.js#L14-L44
+const ALLOWED_RESOURCE_EXT = [
+    // Image formats
+    "bmp",
+    "gif",
+    "jpg",
+    "jpeg",
+    "png",
+    "psd",
+    "svg",
+    "webp",
+    // Video formats
+    "m4v",
+    "mov",
+    "mp4",
+    "mpeg",
+    "mpg",
+    "webm",
+    // Audio formats
+    "aac",
+    "aiff",
+    "caf",
+    "m4a",
+    "mp3",
+    "wav",
+    // Document formats
+    "html",
+    "pdf",
+    "yaml",
+    "yml",
+    "json",
+    // Font formats
+    "otf",
+    "ttf",
+    // Archives (virtual files)
+    "zip",
+    "js",
+];
+let deviceVariables = [];
+let appVersion;
+class AppGenerator {
+    constructor(projectPath, projectService, appUrl, prefabName = "", incBuilder, options, dynamicPrefabProps) {
+        this.projectPath = projectPath;
+        this.projectService = projectService;
+        this.appUrl = appUrl;
+        this.prefabName = prefabName;
+        this.incBuilder = incBuilder;
+        this.options = options;
+        this.dynamicPrefabProps = dynamicPrefabProps;
+        this.transpiledComponents = {
+            pages: {},
+            partials: {},
+            prefabs: {},
+        };
+        this.pageLayoutMap = {};
+        this.generatedRouteGroups = new Set();
+        this.layoutKeyToIdMap = new Map();
+        this.liveVariables = [];
+        this.isPrefabApp = false;
+        this.ResolvePrefabImports = {
+            SCRIPT_IMPORTS: [],
+            NPM_PACKAGES: [],
+        };
+        this.wmxComponents = [];
+        this.isWaveApp = false;
+        this.serviceDefsSource = "STATIC";
+        this.languageBundleSource = "STATIC";
+        this.autolayoutCssRules = new Set();
+        this.isTrue = (value) => {
+            return value === true || value === "true";
+        };
+        this.options = options;
+        this.isPrefabApp = !!prefabName;
+        this.dynamicPrefabProps = dynamicPrefabProps;
+        this.wmxGenerator = new wmx_generator_1.WmxGenerator(projectPath, projectService);
+        this.wmxComponents = this.wmxGenerator.getComponentNames();
+    }
+    prepareVariables(variableJSON, scope, imports) {
+        const variables = Object.values(variableJSON)
+            .map((v) => (0, variable_transformer_1.default)(v, scope, this.appUrl, imports))
+            .filter(v => !!v);
+        const item = VARIABLE_TEMPLATE({
+            scope: scope,
+            imports: imports,
+            addEntityProvider: !this.isPrefabApp && scope !== "App",
+            isPrefabApp: this.isPrefabApp,
+            prefabName: this.prefabName,
+            isPrefabScope: scope === "Prefab",
+            context: {
+                Variables: variables.filter(v => v.group === "variable"),
+                Actions: variables.filter(v => v.group === "action"),
+            },
+        });
+        return item;
+    }
+    isPartial(type) {
+        return (type === "PARTIAL" ||
+            type === "LEFTNAV" ||
+            type === "POPOVER" ||
+            type === "TEMPLATE" ||
+            type === "HEADER" ||
+            type === "FOOTER" ||
+            type === "TOPNAV" ||
+            type === "RIGHTNAV");
+    }
+    resolvePrefabDynamicProps(markup, dynamicPrefabProps) {
+        Object.entries(dynamicPrefabProps).forEach(([key, value]) => {
+            if (value.startsWith("fragment.") &&
+                (markup.includes(`fragment.${key}`) || markup.includes(`fragment?.${key}`))) {
+                value = (0, utils_2.addOptionalChaining)(value);
+                markup = markup.replace(new RegExp(`fragment\\??\\.${key}`, "g"), value);
+            }
+        });
+        return markup;
+    }
+    prettify(target = ALL_GENERATED_FILES) {
+        let prettierPath = null;
+        let d = __dirname;
+        while (d) {
+            prettierPath = d + path_1.sep + "node_modules" + path_1.sep + "prettier";
+            if (fs_extra_1.default.existsSync(prettierPath)) {
+                break;
+            }
+            const s = d.split(path_1.sep);
+            s.pop();
+            d = s.join(path_1.sep);
+        }
+        if (d) {
+            const targetPath = target === ALL_GENERATED_FILES
+                ? `${this.projectPath}/**/*.{ts,tsx,js,jsx,json,css,md}`
+                : `${this.projectPath}/${target}`;
+            return (0, execa_1.default)("node", [`${prettierPath}${path_1.sep}bin/prettier.cjs`, "--write", targetPath]);
+        }
+        console.warn("Prettier is not found");
+        return Promise.reject();
+    }
+    setDeviceVariables(variables) {
+        variables = Object.values(variables);
+        const filterOutput = variables.filter((v) => v.category === "wm.DeviceVariable");
+        deviceVariables = deviceVariables.concat(filterOutput);
+    }
+    generateAppVariables() {
+        if (this.incBuilder) {
+            console.log(`Generating App variables.`);
+        }
+        return this.projectService.getAppVariables().then(variables => {
+            this.setDeviceVariables(variables);
+            Object.keys(variables).map((key) => {
+                // @ts-ignore
+                if (variables[key]["category"] === "wm.LiveVariable") {
+                    // @ts-ignore
+                    this.liveVariables.push(variables[key]);
+                }
+            });
+            const output = this.prepareVariables(variables, "App", []);
+            (0, utils_1.writeFile)(`${this.projectPath}/app/app.variables.ts`, output);
+            // include _app.tsx file in root folder
+            this.generateAppConfig(variables);
+            // include _app.script.js file in root folder
+            this.generateAppScript();
+        });
+    }
+    async generateAppScript() {
+        const script = await this.projectService.getAppScript();
+        // Check if there are any default prefabs in the project
+        const prefabs = await this.projectService.getPrefabs();
+        const hasDefaultPrefabs = prefabs.some((prefab) => ["youtube", "googlemaps", "qrcode"].includes(prefab.toLowerCase()));
+        const appScript = APP_SCRIPT_TEMPLATE({
+            script: script,
+            hasDefaultPrefabs: hasDefaultPrefabs,
+        });
+        (0, utils_1.writeFile)(`${this.projectPath}/app/app.script.js`, appScript);
+        // Generate app.libs.js
+        const appLibs = APP_LIBS_TEMPLATE({
+            hasDefaultPrefabs: hasDefaultPrefabs,
+        });
+        (0, utils_1.writeFile)(`${this.projectPath}/app/app.libs.js`, appLibs);
+    }
+    async generateAppConfig(variables) {
+        // create _app file and populate data
+        const App = APP_TEMPLATE({
+            startUpVariables: Object.values(variables)
+                .filter((v) => v.startUpdate && v.category !== "wm.TimerAction")
+                .map((v) => v.name),
+            startUpActions: Object.values(variables)
+                .filter((v) => v.startUpdate && v.category === "wm.TimerAction")
+                .map((v) => v.name),
+            autoUpdateVariables: Object.values(variables)
+                .filter((v) => v.autoUpdate ||
+                ((v.category === "wm.Variable" || v.category === "wm.LiveVariable") &&
+                    v.dataBinding &&
+                    v.dataBinding.length))
+                .map((v) => v.name),
+        });
+        (0, utils_1.writeFile)(`${this.projectPath}/app/_app.tsx`, App);
+    }
+    getBasePath() {
+        var _a, _b;
+        // First check if appBasePath is provided via command line
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.appBasePath) {
+            if (!((_b = this.options) === null || _b === void 0 ? void 0 : _b.isServerPath)) {
+                (0, utils_1.updateEnvFile)(this.projectPath, { NEXT_PUBLIC_BASE_PATH: this.options.appBasePath });
+            }
+            return this.options.appBasePath;
+        }
+        return "";
+    }
+    generatePageConfig(pageConfigs, isPartOfPrefab) {
+        pageConfigs = pageConfigs.filter((p) => p.type == "PAGE");
+        const output = PAGE_CONFIG_TEMPLATE({
+            pageConfigs: pageConfigs,
+            pageConfigsStr: JSON.stringify(pageConfigs),
+            lazyload: profile_1.default.lazyloadPages,
+        });
+        let path = isPartOfPrefab
+            ? `${this.projectPath}/pages-config.ts`
+            : `${this.projectPath}/app/pages-config.ts`;
+        (0, utils_1.writeFile)(path, output);
+    }
+    generatePartialConfig(pageConfigs, isPartOfPrefab) {
+        pageConfigs = pageConfigs.filter((p) => this.isPartial(p.type));
+        const output = PARTIAL_CONFIG_TEMPLATE({
+            pageConfigs: pageConfigs,
+            pageConfigsStr: JSON.stringify(pageConfigs),
+            lazyload: profile_1.default.lazyloadPartials,
+        });
+        let path = isPartOfPrefab
+            ? `${this.projectPath}/components/partial-config.ts`
+            : `${this.projectPath}/app/components/partial-config.ts`;
+        (0, utils_1.writeFile)(path, output);
+    }
+    extractRefsFromMarkup(markup) {
+        const refs = [];
+        const regex = /<\w+[^>]*\bname=["']([^"']+)["']/g; // Match any component with a `name` property
+        let match;
+        while ((match = regex.exec(markup)) !== null) {
+            refs.push(match[1]); // Extract the name
+        }
+        return refs;
+    }
+    generateComponent(info, type, name, isPartOfPrefab) {
+        var _a, _b, _c, _d;
+        if (this.incBuilder && !this.incBuilder.isFragmentModified(name)) {
+            return Promise.resolve();
+        }
+        if (this.incBuilder) {
+            console.log(`Generating ${name} component.`);
+        }
+        const lType = type.toLowerCase();
+        const typeLabel = (0, lodash_1.capitalize)(type);
+        let variables = {};
+        try {
+            variables = info.variables ? JSON.parse(info.variables) : {};
+        }
+        catch (_e) {
+            console.log(`Error parsing variables for ${name}, skipping variables.`);
+            variables = {};
+        }
+        Object.keys(variables).map(key => {
+            if (variables[key]["category"] === "wm.LiveVariable") {
+                this.liveVariables.push(variables[key]);
+            }
+        });
+        this.setDeviceVariables(variables);
+        // let dest = type === 'PREFAB' ? `${this.projectPath}/app/${name}` : `${this.projectPath}/app/${name}`;
+        let dest = "";
+        if (type === "PREFAB") {
+            dest = `${this.projectPath}/${name}`;
+        }
+        else if (type === "PAGE") {
+            const layoutId = (_a = this.pageLayoutMap) === null || _a === void 0 ? void 0 : _a[name];
+            const groupPrefix = layoutId ? `/(${layoutId})` : "";
+            dest = `${this.projectPath}/app/react-pages${groupPrefix}/${name}`;
+        }
+        else {
+            dest = isPartOfPrefab
+                ? `${this.projectPath}/components/${name}`
+                : `${this.projectPath}/app/components/${name}`;
+        }
+        try {
+            const output = this.prepareVariables(variables, typeLabel, []);
+            (0, utils_1.writeFile)(`${dest}/${name}.variables.ts`, output);
+            const transpiledOutput = (0, transpile_1.transpileMarkup)(info.markup, this.isPrefabApp, undefined, variables);
+            if (transpiledOutput.autolayoutCss) {
+                transpiledOutput.autolayoutCss.forEach(rule => this.autolayoutCssRules.add(rule));
+            }
+            let imports = (0, lodash_1.sortBy)((0, lodash_1.uniqBy)(transpiledOutput.imports, i => i.name + i.from), i => i.name);
+            const _markup = "\n" + transpiledOutput.markup;
+            const dynamicRefs = this.extractRefsFromMarkup(_markup);
+            const TEMPLATE_TYPE = this.isPartial(type) ? PARTIAL_TEMPLATE : COMPONENT_TEMPLATE;
+            if (this.dynamicPrefabProps && Object.keys(this.dynamicPrefabProps).length > 0) {
+                transpiledOutput.markup = this.resolvePrefabDynamicProps(transpiledOutput.markup, this.dynamicPrefabProps);
+            }
+            let effectiveMarkup = transpiledOutput.markup;
+            if (type === "PAGE") {
+                const hasLayout = (_b = this.pageLayoutMap) === null || _b === void 0 ? void 0 : _b[name];
+                if (hasLayout) {
+                    effectiveMarkup = (0, grouping_util_1.extractInnerPageContent)(transpiledOutput.markup);
+                    imports = (0, grouping_util_1.filterImportsByMarkup)(effectiveMarkup, imports);
+                }
+            }
+            const component = TEMPLATE_TYPE({
+                name: name,
+                componentName: (name.charAt(0).toUpperCase() + name.substring(1)).replace(/-/g, ""),
+                type: type,
+                lType: lType,
+                typeLabel: typeLabel,
+                prefabName: this.prefabName,
+                markup: "\n" + (0, utils_1.fixURLPath)(effectiveMarkup, this.getBasePath()),
+                components: transpiledOutput.components,
+                pageEvents: transpiledOutput.pageEvents,
+                startUpVariables: Object.values(variables)
+                    .filter((v) => v.startUpdate && v.category !== "wm.TimerAction")
+                    .map((v) => v.name),
+                startUpActions: Object.values(variables)
+                    .filter((v) => v.startUpdate && v.category === "wm.TimerAction")
+                    .map((v) => v.name),
+                autoUpdateVariables: Object.values(variables)
+                    .filter((v) => v.autoUpdate ||
+                    ((v.category === "wm.Variable" || v.category === "wm.LiveVariable") &&
+                        v.dataBinding &&
+                        v.dataBinding.length))
+                    .map((v) => v.name),
+                eagerImports: imports.filter(i => !i.lazy),
+                lazyImports: imports.filter(i => i.lazy),
+                dynamicRefs,
+            });
+            if (type === "PAGE") {
+                const componentName = (name.charAt(0).toUpperCase() + name.substring(1)).replace(/-/g, "");
+                const pageTitleMatch = (_c = info.markup) === null || _c === void 0 ? void 0 : _c.match(/pagetitle=["']([^"']+)["']/i);
+                const rawPageTitle = (_d = pageTitleMatch === null || pageTitleMatch === void 0 ? void 0 : pageTitleMatch[1]) === null || _d === void 0 ? void 0 : _d.trim();
+                const isExpression = rawPageTitle && /^(bind:|{{)/.test(rawPageTitle);
+                const pageTitle = rawPageTitle && rawPageTitle.length > 0 && !isExpression ? rawPageTitle : componentName;
+                const componentPage = COMPONENT_PAGE_TEMPLATE({
+                    name: name,
+                    type: type,
+                    lType: lType,
+                    componentName: (name.charAt(0).toUpperCase() + name.substring(1)).replace(/-/g, ""),
+                    pageTitle: pageTitle,
+                    typeLabel: typeLabel,
+                    dynamicPrefabProps: this.dynamicPrefabProps || {},
+                    prefabName: this.prefabName,
+                    markup: "\n" + (0, utils_1.fixURLPath)(effectiveMarkup, this.getBasePath()),
+                    components: transpiledOutput.components,
+                    startUpVariables: Object.values(variables)
+                        .filter((v) => v.startUpdate && v.category !== "wm.TimerAction")
+                        .map((v) => v.name),
+                    startUpActions: Object.values(variables)
+                        .filter((v) => v.startUpdate && v.category === "wm.TimerAction")
+                        .map((v) => v.name),
+                    autoUpdateVariables: Object.values(variables)
+                        .filter((v) => v.autoUpdate ||
+                        ((v.category === "wm.Variable" || v.category === "wm.LiveVariable") &&
+                            v.dataBinding &&
+                            v.dataBinding.length))
+                        .map((v) => v.name),
+                    eagerImports: imports.filter(i => !i.lazy),
+                    lazyImports: imports.filter(i => i.lazy),
+                });
+                (0, utils_1.writeFile)(`${dest}/${name}.component.tsx`, component);
+                (0, utils_1.writeFile)(`${dest}/page.tsx`, componentPage);
+            }
+            else {
+                (0, utils_1.writeFile)(`${dest}/${name}.tsx`, component);
+            }
+            const script = SCRIPT_TEMPLATE({
+                typeLabel: typeLabel,
+                script: info.script,
+            });
+            (0, utils_1.writeFile)(`${dest}/${name}.script.js`, script);
+            const updatedCss = (0, utils_1.fixURLPathAndScope)(info.styles, this.getBasePath(), true);
+            (0, utils_1.writeFile)(`${dest}/${name}.css`, updatedCss);
+            return Promise.all(transpiledOutput.prefabs.map(p => this.generatePrefabComponent(p, false))).then(() => {
+                return Promise.all(transpiledOutput.wmxcomponents.map((c) => this.wmxGenerator.generate(c, false)));
+            });
+        }
+        catch (e) {
+            console.log(`failed to generate component ${dest}/${name}`);
+            throw e;
+        }
+    }
+    generatePrefabProps(name, projectPath) {
+        const dynamicProps = {};
+        return this.projectService.getPrefabInfo(name).then(info => {
+            const propConfig = {};
+            Object.keys(info.config.properties).map((k) => {
+                let value = info.config.properties[k].value;
+                const type = info.config.properties[k].type;
+                if (type === "number" || type == "integer") {
+                    value = Number(value);
+                }
+                if (type === "boolean") {
+                    value = Boolean(value);
+                }
+                if ((0, lodash_1.isString)(value) && value.startsWith("bind:")) {
+                    let exStr = decodeURIComponent(value.substring(5));
+                    dynamicProps[k] = `${(0, bind_ex_transformer_1.default)(exStr, "fragment", "attr")}`;
+                    propConfig[k] = null;
+                }
+                else {
+                    propConfig[k] = value === undefined ? null : value;
+                }
+            });
+            let propsStr = JSON.stringify(propConfig);
+            if (info.config.events) {
+                propsStr = propsStr.replace(/\}$/, "");
+                Object.keys(info.config.events).map((k) => {
+                    propsStr += `${propsStr.length === 1 ? "" : ","} ${k} : () => {}`;
+                });
+                propsStr += "}";
+            }
+            const props = COMPONENT_PROPS_TEMPLATE({
+                props: propsStr,
+            });
+            (0, utils_1.writeFile)(`${projectPath}/app/prefabs/${name}/Main/Main.props.js`, props);
+            return dynamicProps;
+        });
+    }
+    generatePrefabComponent(name, overwrite = true) {
+        var _a;
+        if ((!overwrite && this.transpiledComponents.prefabs[name]) ||
+            (this.incBuilder && !((_a = this.incBuilder) === null || _a === void 0 ? void 0 : _a.isPrefabModified(name)))) {
+            return Promise.resolve();
+        }
+        if (this.incBuilder) {
+            console.log(`Generating ${name} prefab component.`);
+        }
+        const projectPath = this.isPrefabApp
+            ? this.projectPath.split("/app/prefabs/")[0]
+            : this.projectPath;
+        const appUrl = this.isPrefabApp ? this.appUrl.split("/app/prefabs/")[0] : this.appUrl;
+        this.transpiledComponents.prefabs[name] = true;
+        return this.generatePrefabProps(name, projectPath).then(dynamicPrefabProps => {
+            const prefabGenerator = new AppGenerator(`${projectPath}/app/prefabs/${name}`, this.projectService.getPrefabProjectService(name), `${appUrl}/app/prefabs/${name}`, name, undefined, undefined, dynamicPrefabProps);
+            return prefabGenerator
+                .generatePagesAndPartials(true)
+                .then(() => this.copyPrefabResources(projectPath, name))
+                .then(() => this.addPrefabLibsToLayout(prefabGenerator.projectPath, name));
+        });
+    }
+    addPrefabLibsToLayout(projectPath, prefabName) {
+        if (!projectPath || !prefabName)
+            return;
+        return this.projectService.getPrefabIndexHtml(prefabName).then(html => {
+            this.IncludeHtmlLibs(html);
+            return Promise.resolve({});
+        });
+    }
+    addIndexHtmlToLayout() {
+        if (this.isPrefabApp)
+            return Promise.resolve();
+        return this.projectService
+            .getIndexHtml()
+            .then(html => {
+            this.IncludeHtmlLibs(html);
+            return Promise.resolve({});
+        })
+            .catch(() => Promise.resolve({}));
+    }
+    copyPrefabResources(projectPath, prefabName) {
+        if (!projectPath || !prefabName)
+            return;
+        return this.projectService.getPrefabResources(prefabName).then(p => {
+            if (p) {
+                const dest = `${projectPath}/public/${prefabName}/resources`;
+                fs_extra_1.default.copySync(p, dest, {
+                    filter: (src) => {
+                        return !src.includes(path_2.default.sep + "i18n" + path_2.default.sep) && !src.endsWith(path_2.default.sep + "i18n");
+                    },
+                });
+            }
+            this.resolvePrefabImports(prefabName).then(res => {
+                if (res.CSS_IMPORTS.length) {
+                    // Filter imports to only include files that actually exist
+                    const validImports = res.CSS_IMPORTS.filter((importPath) => {
+                        const fullPath = path_2.default.resolve(projectPath, importPath);
+                        const exists = fs_extra_1.default.existsSync(fullPath);
+                        if (!exists) {
+                            console.warn(`CSS import file not found: ${fullPath}, skipping import`);
+                        }
+                        return exists;
+                    });
+                    if (validImports.length > 0) {
+                        const imports = validImports.map((i) => `import "${i}";`).join("\n");
+                        const mainFilePath = `${projectPath}/app/prefabs/${prefabName}/Main/Main.tsx`;
+                        if (fs_extra_1.default.existsSync(mainFilePath)) {
+                            const mainContent = fs_extra_1.default.readFileSync(mainFilePath, "utf-8");
+                            // Find the first line and insert imports after it
+                            const lines = mainContent.split("\n");
+                            const updatedContent = `${lines[0]}\n${imports}\n${lines.slice(1).join("\n")}`;
+                            fs_extra_1.default.writeFileSync(mainFilePath, updatedContent);
+                        }
+                    }
+                }
+            });
+            return Promise.resolve({});
+        });
+    }
+    resolvePrefabImports(name) {
+        return this.projectService.getPrefabInfo(name).then(info => {
+            var _a;
+            const NPM_PACKAGES = [];
+            const CSS_IMPORTS = [];
+            info.config.resources.styles.forEach((item) => {
+                if (!item.endsWith("Main.css")) {
+                    CSS_IMPORTS.push(`public/${name}${item}`);
+                }
+            }) || [];
+            const SCRIPT_IMPORTS = info.config.resources.scripts.map((item) => {
+                if (item.startsWith("npm://")) {
+                    NPM_PACKAGES.push(item.replace("npm://", ""));
+                }
+                else if (item.startsWith("http")) {
+                    return item;
+                }
+                else {
+                    return `/${name}${item}`;
+                }
+            });
+            this.ResolvePrefabImports = {
+                SCRIPT_IMPORTS: [...(_a = this.ResolvePrefabImports) === null || _a === void 0 ? void 0 : _a.SCRIPT_IMPORTS, ...SCRIPT_IMPORTS],
+                NPM_PACKAGES: [...this.ResolvePrefabImports.NPM_PACKAGES, ...NPM_PACKAGES],
+            };
+            return Promise.resolve({
+                CSS_IMPORTS: CSS_IMPORTS || [],
+            });
+        });
+    }
+    generateAllPrefabComponents(overwrite) {
+        return this.projectService.getPrefabs().then(prefabs => {
+            return Promise.all(prefabs === null || prefabs === void 0 ? void 0 : prefabs.map(prefab => this.generatePrefabComponent(prefab, overwrite)));
+        });
+    }
+    generatePageComponent(name, overwrite = true, isPartOfPrefab) {
+        if (!overwrite && this.transpiledComponents.pages[name]) {
+            return Promise.resolve();
+        }
+        this.transpiledComponents.pages[name] = true;
+        return this.projectService.getPageInfo(name).then(info => {
+            if (!info) {
+                console.log(`Page ${name} not found, skipping.`);
+                return Promise.resolve();
+            }
+            return this.generateComponent(info, this.isPrefabApp ? "PREFAB" : "PAGE", name, isPartOfPrefab);
+        });
+    }
+    generatePartialComponent(name, overwrite = true, isPartOfPrefab) {
+        if (!overwrite && this.transpiledComponents.partials[name]) {
+            return Promise.resolve();
+        }
+        this.transpiledComponents.partials[name] = true;
+        return this.projectService.getPageInfo(name).then(info => {
+            if (!info) {
+                console.log(`Partial ${name} not found, skipping.`);
+                return Promise.resolve();
+            }
+            return this.generateComponent(info, "PARTIAL", name, isPartOfPrefab);
+        });
+    }
+    ensureRouteGroupLayout(layoutId, config = {}) {
+        if (!layoutId)
+            return;
+        if (this.generatedRouteGroups.has(layoutId))
+            return;
+        const groupDir = `${this.projectPath}/app/react-pages/(${layoutId})`;
+        const layoutFile = `${groupDir}/layout.tsx`;
+        const content = LAYOUT_TEMPLATE({
+            components: config.scaffoldMarkup,
+            eagerImports: config.eagerImports || [],
+            lazyImports: config.lazyImports || [],
+        });
+        (0, utils_1.writeFile)(layoutFile, content);
+        this.generatedRouteGroups.add(layoutId);
+    }
+    generateAppStyles() {
+        if (this.incBuilder) {
+            console.log(`Generating app.styles.css .`);
+        }
+        return this.projectService.getAppCss().then(response => {
+            const basePath = this.getBasePath();
+            const updatedCss = (0, utils_1.fixURLPath)(response, basePath, true);
+            (0, utils_1.writeFile)(`${this.projectPath}/app/app.css`, updatedCss);
+        });
+    }
+    generateAutoLayoutCSS() {
+        if (this.autolayoutCssRules.size === 0)
+            return;
+        const cssPath = `${this.projectPath}/app/autoLayout.css`;
+        fs_extra_1.default.appendFileSync(cssPath, "\n" + Array.from(this.autolayoutCssRules).join("\n\n") + "\n");
+    }
+    getAllResources(filter = (str) => true, dirPath = this.projectPath + "/assets/resources", pathPrefix = "resources", arrayOfFiles = []) {
+        if (fs_extra_1.default.existsSync(dirPath)) {
+            fs_extra_1.default.readdirSync(dirPath).forEach(file => {
+                if (fs_extra_1.default.statSync(dirPath + "/" + file).isDirectory()) {
+                    arrayOfFiles = this.getAllResources(filter, dirPath + "/" + file, pathPrefix + "/" + file, arrayOfFiles);
+                }
+                else if (filter(dirPath + "/" + file)) {
+                    const ext = (0, lodash_1.last)(file.split("."));
+                    if (file.indexOf("@") < 0 && ALLOWED_RESOURCE_EXT.indexOf(ext || "") >= 0) {
+                        arrayOfFiles.push(pathPrefix + "/" + file);
+                    }
+                }
+            });
+        }
+        return arrayOfFiles;
+    }
+    copyi18nFiles() {
+        if (this.incBuilder) {
+            console.log(`Copying i18n files.`);
+        }
+        if (this.languageBundleSource !== "STATIC") {
+            return Promise.resolve({});
+        }
+        return this.projectService.geti18NFiles().then(p => {
+            if (p) {
+                fs_extra_1.default.copySync(p, this.projectPath + "/public/resources/i18n");
+            }
+            return Promise.resolve({});
+        });
+    }
+    copyServiceDefs() {
+        if (this.serviceDefsSource !== "STATIC") {
+            return Promise.resolve();
+        }
+        return this.projectService.getServiceDefsPath().then(serviceDefsPath => {
+            const targetDir = path_2.default.resolve(this.projectPath + "/public/services");
+            try {
+                // Copy regular service defs
+                if (fs_extra_1.default.existsSync(serviceDefsPath)) {
+                    fs_extra_1.default.mkdirSync(targetDir, { recursive: true });
+                    const sourceFile = path_2.default.join(serviceDefsPath, "app-servicedefs.json");
+                    const targetFile = path_2.default.join(targetDir, "servicedefs.json");
+                    if (fs_extra_1.default.existsSync(sourceFile)) {
+                        fs_extra_1.default.copyFileSync(sourceFile, targetFile);
+                        console.log("Service defs copied to servicedefs");
+                    }
+                    else {
+                        console.warn(`Source file does not exist: ${sourceFile}`);
+                    }
+                }
+                else {
+                    console.warn(`Source directory does not exist: ${serviceDefsPath}`);
+                }
+                // Copy prefab service defs
+                const normalizedPath = serviceDefsPath.replace(/[/\\]$/, ""); // Remove trailing slash
+                const prefabSourceDir = normalizedPath.replace(/servicedefs$/, "prefabs");
+                if (fs_extra_1.default.existsSync(prefabSourceDir)) {
+                    // Ensure target directory exists
+                    fs_extra_1.default.mkdirSync(targetDir, { recursive: true });
+                    // Read all prefab directories
+                    const prefabDirs = fs_extra_1.default
+                        .readdirSync(prefabSourceDir, { withFileTypes: true })
+                        .filter((dirent) => dirent.isDirectory())
+                        .map((dirent) => dirent.name);
+                    let copiedCount = 0;
+                    // Process each prefab directory
+                    prefabDirs.forEach((prefabName) => {
+                        const prefabSourcePath = path_2.default.join(prefabSourceDir, prefabName, "prefab-servicedefs.json");
+                        const prefabTargetDir = path_2.default.join(targetDir, "prefabs", prefabName);
+                        const prefabTargetPath = path_2.default.join(prefabTargetDir, "servicedefs.json");
+                        // Check if prefab-servicedefs.json exists
+                        if (fs_extra_1.default.existsSync(prefabSourcePath)) {
+                            // Create target directory for this prefab
+                            fs_extra_1.default.mkdirSync(prefabTargetDir, { recursive: true });
+                            // Copy and rename the file
+                            fs_extra_1.default.copyFileSync(prefabSourcePath, prefabTargetPath);
+                            copiedCount++;
+                            console.log(`Copied prefab service defs: ${prefabName} -> services/prefabs/${prefabName}/servicedefs.json`);
+                        }
+                    });
+                    if (copiedCount > 0) {
+                        console.log(`✅ Copied ${copiedCount} prefab service defs to servicedefs`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error copying service defs:", error);
+            }
+        });
+    }
+    copyThemesFiles() {
+        return this.projectService
+            .getThemesFiles(this.isWaveApp)
+            .then(p => {
+            try {
+                if (p && this.isWaveApp) {
+                    fs_extra_1.default.copySync(p, this.projectPath + "/public/design-tokens");
+                }
+                else if (p) {
+                    fs_extra_1.default.copySync(p, this.projectPath + "/public/themes");
+                }
+                return Promise.resolve({});
+            }
+            catch (error) {
+                console.warn("Warning: Failed to copy theme files:", error);
+                return Promise.resolve({});
+            }
+        })
+            .catch(error => {
+            console.warn("Warning: Failed to get theme files:", error === null || error === void 0 ? void 0 : error.message);
+            return Promise.resolve({});
+        });
+    }
+    copyFavIcon() {
+        return this.projectService.getFavIcon().then(p => {
+            if (p && fs_extra_1.default.existsSync(p)) {
+                const dest = `${this.projectPath}/public/favicon.png`;
+                fs_extra_1.default.copySync(p, dest);
+            }
+            return Promise.resolve({});
+        });
+    }
+    async generateOverrideCSS(options) {
+        var _a;
+        // this.projectPath is the generated React app directory (e.g., temp/App)
+        // We need to pass the source project root from projectService
+        const sourceProjectPath = this.projectService.path;
+        // Get project root directory (parent of src/main/webapp or WEB-INF)
+        const projectRoot = sourceProjectPath.replace(/[\/\\](src[\/\\]main[\/\\]webapp|WEB-INF).*$/, "");
+        // this is only for local development, this block will not work in prod build
+        console.log("isLocal===>", options === null || options === void 0 ? void 0 : options.isLocal);
+        if (this.isTrue(options === null || options === void 0 ? void 0 : options.isLocal)) {
+            console.log("generateOverrideCss paths", "projectRoot===", projectRoot, "projectPath===", this.projectPath);
+            await (0, gen_app_override_css_1.generateOverrideCSS)({
+                runtimeUIVersion: ((_a = this.options) === null || _a === void 0 ? void 0 : _a.runtimeUIVersion) || "latest",
+            }, projectRoot, this.projectPath);
+        }
+        return Promise.resolve();
+    }
+    async generateFontConfig() {
+        if (this.incBuilder) {
+            console.log("Generating Font config.");
+        }
+        try {
+            const code = await this.projectService.getFontConfig();
+            await (0, utils_1.writeFile)(`${this.projectPath}/app/font.config.ts`, code);
+            this.IncludeScriptImports();
+        }
+        catch (e) {
+            console.log("Error generating font.config.js", e);
+        }
+    }
+    async IncludeHtmlLibs(html) {
+        try {
+            let layoutContent = fs_extra_1.default.readFileSync(`${this.projectPath}/app/layout.tsx`, "utf-8");
+            // optimization to keep the original “only write when we changed something” behavior.
+            let hasChanges = false;
+            // Extract script and link tags, passing layoutContent to avoid duplicates
+            const scriptsElements = (0, utils_1.extractScriptAndLinkTags)(html, layoutContent);
+            // Only update if there are new elements to add
+            if (scriptsElements && scriptsElements.trim()) {
+                hasChanges = true;
+                // Find the position of </head> and insert before it
+                // This preserves existing imports
+                const headCloseIndex = layoutContent.lastIndexOf("</head>");
+                if (headCloseIndex !== -1) {
+                    const beforeHead = layoutContent.substring(0, headCloseIndex);
+                    const afterHead = layoutContent.substring(headCloseIndex);
+                    layoutContent = `${beforeHead}
+                                    ${scriptsElements}
+                                  ${afterHead}`;
+                }
+                else {
+                    // Fallback to original method if </head> not found
+                    layoutContent = layoutContent.replace(/\s*<\/head>/, `
+              ${scriptsElements}\n
+            </head>`);
+                }
+            }
+            // Splash screen support: extract interactive-container div (if present), convert to JSX, insert into body
+            const interactiveContainerHtml = (0, utils_1.extractInteractiveContainerDiv)(html);
+            if (interactiveContainerHtml && !layoutContent.includes("interactive-container")) {
+                hasChanges = true;
+                const interactiveContainerJsx = (0, utils_1.htmlToJsx)(interactiveContainerHtml);
+                const bodyOpenMatch = layoutContent.match(/(<body[^>]*>)/);
+                if ((bodyOpenMatch === null || bodyOpenMatch === void 0 ? void 0 : bodyOpenMatch.index) !== undefined) {
+                    const insertIndex = bodyOpenMatch.index + bodyOpenMatch[1].length;
+                    layoutContent =
+                        layoutContent.slice(0, insertIndex) +
+                            `\n        ${interactiveContainerJsx}\n        ` +
+                            layoutContent.slice(insertIndex);
+                }
+            }
+            if (hasChanges) {
+                fs_extra_1.default.writeFileSync(`${this.projectPath}/app/layout.tsx`, layoutContent, "utf-8");
+            }
+        }
+        catch (e) {
+            console.log("Error in IncludePrefabsHtmlLibs:", e);
+        }
+    }
+    async IncludeScriptImports() {
+        try {
+            const layoutContent = fs_extra_1.default.readFileSync(`${this.projectPath}/app/layout.tsx`, "utf-8");
+            const fontConfig = await Promise.resolve(`${`${this.projectPath}/app/font.config.ts`}`).then(s => __importStar(require(s)));
+            const fonts = fontConfig.default.fonts;
+            if (!fonts || fonts.length === 0) {
+                return;
+            }
+            const scriptsElements = fonts
+                .map((file) => {
+                let links = "";
+                if (file === null || file === void 0 ? void 0 : file.csspath) {
+                    links += `<link rel="stylesheet" href={\`\${configs.appConfig.basePath}${file.csspath}\`} />\n`;
+                }
+                if (file === null || file === void 0 ? void 0 : file.path) {
+                    links += `<link rel="preload" href={\`\${configs.appConfig.basePath}${file.path}\`} />\n`;
+                }
+                return links;
+            })
+                .filter(Boolean)
+                .join("\n");
+            const updatedContent = layoutContent.replace(/\s*<\/head>/, `
+        ${scriptsElements}\n
+        </head>`);
+            fs_extra_1.default.writeFileSync(`${this.projectPath}/app/layout.tsx`, updatedContent, "utf-8");
+        }
+        catch (e) {
+            console.log("Error in IncludeScriptImports:", e);
+        }
+    }
+    async copyResource() {
+        return this.projectService.getResources().then(p => {
+            if (p) {
+                const dest = `${this.projectPath}${!this.isPrefabApp ? "/public" : ""}/resources`;
+                if (this.languageBundleSource !== "STATIC") {
+                    fs_extra_1.default.copySync(p, dest, {
+                        filter: (src) => {
+                            return (!src.includes(path_2.default.sep + "i18n" + path_2.default.sep) && !src.endsWith(path_2.default.sep + "i18n"));
+                        },
+                    });
+                }
+                else {
+                    fs_extra_1.default.copySync(p, dest);
+                }
+            }
+            return Promise.resolve({});
+        });
+    }
+    generatePagesAndPartials(isPartOfPrefab) {
+        let pageConfigs = null;
+        let securityConfigs = null;
+        return this.projectService
+            .getPageConfigs()
+            .then(_pageConfigs => {
+            pageConfigs = _pageConfigs;
+            return this.projectService.getSecurityConfig();
+        })
+            .then(_securityConfigs => {
+            securityConfigs = _securityConfigs;
+            pageConfigs = pageConfigs.map((p) => {
+                const matchingSecurity = securityConfigs.find((sec) => {
+                    if (isPartOfPrefab) {
+                        //search for prefab name since all pages inside the prefab we get main.tsx file
+                        return sec.urlPattern.includes(`/prefabs/${this.prefabName}`);
+                    }
+                    else {
+                        return sec.urlPattern.includes(`/pages/${p.name}`);
+                    }
+                });
+                //Common page have always access to everyone
+                if (p.name === "Common" && !isPartOfPrefab) {
+                    return Object.assign({}, p, {
+                        allowedRoles: [],
+                        permission: "PermitAll",
+                    });
+                }
+                if (matchingSecurity) {
+                    return Object.assign({}, p, {
+                        allowedRoles: matchingSecurity.roles,
+                        permission: matchingSecurity.permission,
+                    });
+                }
+                return Object.assign({}, p, {
+                    permission: "Authenticated",
+                });
+            });
+            // Build layout map and create route group layouts (auto-detect when layoutId absent)
+            this.pageLayoutMap = {};
+            const pageNames = (pageConfigs || [])
+                .filter((p) => p.type === "PAGE")
+                .map((p) => p.name);
+            return Promise.all(pageNames.map(n => this.projectService.getPageInfo(n))).then(pageInfos => {
+                // Pass 1: count pages per layout (only create layout when 2+ pages share it)
+                const layoutIdToPageCount = {};
+                const pageToLayoutId = {};
+                const layoutIdToScaffoldConfig = {};
+                pageInfos.forEach((info, idx) => {
+                    const pageName = pageNames[idx];
+                    const pageConfig = pageConfigs.find((p) => p.name === pageName);
+                    if ((pageConfig === null || pageConfig === void 0 ? void 0 : pageConfig.type) !== "PAGE")
+                        return;
+                    const declaredLayoutId = pageConfig === null || pageConfig === void 0 ? void 0 : pageConfig.layoutId;
+                    if (!(info === null || info === void 0 ? void 0 : info.markup))
+                        return;
+                    if (declaredLayoutId) {
+                        pageToLayoutId[pageName] = declaredLayoutId;
+                        layoutIdToPageCount[declaredLayoutId] =
+                            (layoutIdToPageCount[declaredLayoutId] || 0) + 1;
+                        return;
+                    }
+                    const layoutInfo = (0, grouping_util_1.detectLayoutInfoFromMarkup)(info.markup);
+                    const key = (0, grouping_util_1.getLayoutKey)(layoutInfo);
+                    if (key === "empty")
+                        return;
+                    if (!this.layoutKeyToIdMap.has(key)) {
+                        const layoutId = `layout${this.layoutKeyToIdMap.size + 1}`;
+                        this.layoutKeyToIdMap.set(key, { layoutId, config: layoutInfo });
+                    }
+                    const group = this.layoutKeyToIdMap.get(key);
+                    pageToLayoutId[pageName] = group.layoutId;
+                    layoutIdToPageCount[group.layoutId] = (layoutIdToPageCount[group.layoutId] || 0) + 1;
+                    const transpiled = (0, transpile_1.transpileMarkup)(info.markup, this.isPrefabApp);
+                    let scaffoldMarkup = (0, grouping_util_1.buildScaffoldMarkup)(transpiled.markup);
+                    scaffoldMarkup = (0, grouping_util_1.stripNonLayoutRegionsFromScaffold)(scaffoldMarkup);
+                    const layoutImports = (0, grouping_util_1.filterImportsForLayoutScaffold)(scaffoldMarkup, transpiled.imports || []);
+                    layoutIdToScaffoldConfig[group.layoutId] = {
+                        scaffoldMarkup,
+                        eagerImports: layoutImports.filter((i) => !i.lazy),
+                        lazyImports: layoutImports.filter((i) => i.lazy),
+                    };
+                });
+                // Pass 2: only use layout for groups with 2+ pages; single-page layouts stay as plain pages
+                Object.entries(pageToLayoutId).forEach(([pageName, layoutId]) => {
+                    const count = layoutIdToPageCount[layoutId] || 0;
+                    if (count >= 2) {
+                        this.pageLayoutMap[pageName] = layoutId;
+                        const config = layoutIdToScaffoldConfig[layoutId];
+                        this.ensureRouteGroupLayout(layoutId, config || {});
+                    }
+                });
+                // After grouping is prepared, create pages/partials
+                const pageCreationPromises = pageConfigs.map(p => {
+                    if (p.type === "PAGE") {
+                        return this.generatePageComponent(p.name, isPartOfPrefab);
+                    }
+                    if (this.isPartial(p.type)) {
+                        return this.generatePartialComponent(p.name, true, isPartOfPrefab);
+                    }
+                });
+                return Promise.all(pageCreationPromises).then(() => undefined);
+            });
+            // page/partial generation handled in previous step
+            return Promise.resolve();
+        })
+            .then(() => this.generatePageConfig(pageConfigs, isPartOfPrefab))
+            .then(() => this.generatePartialConfig(pageConfigs, isPartOfPrefab));
+    }
+    generateEntityMetadata() {
+        if (this.incBuilder) {
+            console.log(`Generating Entity data.`);
+        }
+        const liveSources = {};
+        this.liveVariables.forEach((lv) => {
+            const liveSource = lv.liveSource;
+            const entityName = lv.type;
+            if (!liveSources[liveSource]) {
+                liveSources[liveSource] = {};
+            }
+            const existing = liveSources[liveSource][entityName];
+            const hasNewData = lv.propertiesMap != null || lv.relatedTables != null;
+            const existingEmpty = !existing || (existing.propertiesMap == null && existing.relatedTables == null);
+            if (!existing || (existingEmpty && hasNewData)) {
+                liveSources[liveSource][entityName] = {
+                    propertiesMap: lv.propertiesMap,
+                    relatedTables: lv.relatedTables,
+                };
+            }
+        });
+        Object.keys(liveSources).forEach((liveSource) => {
+            (0, utils_1.writeFile)(`${this.projectPath}/libs/metadata/entities/${liveSource}.json`, JSON.stringify(liveSources[liveSource], null, 4));
+        });
+        const output = ENTITY_PROVIDER_TEMPLATE({
+            liveSources: Object.keys(liveSources),
+        });
+        (0, utils_1.writeFile)(`${this.projectPath}/libs/metadata/entities/entity-provider.js`, output);
+    }
+    async resolvePackage() {
+        const { SCRIPT_IMPORTS, NPM_PACKAGES } = this.ResolvePrefabImports;
+        if (SCRIPT_IMPORTS.length > 0) {
+            const layoutPath = `${this.projectPath}/app/layout.tsx`;
+            if (fs_extra_1.default.existsSync(layoutPath)) {
+                const layoutContent = fs_extra_1.default.readFileSync(layoutPath, "utf-8");
+                // Filter script imports to only include files that actually exist
+                const validScriptImports = SCRIPT_IMPORTS.filter((script) => {
+                    // Skip HTTP URLs - they are external scripts
+                    if (script.startsWith("http")) {
+                        return true;
+                    }
+                    const fullPath = path_2.default.resolve(this.projectPath, `public/${script}`);
+                    const exists = fs_extra_1.default.existsSync(fullPath);
+                    if (!exists) {
+                        console.warn(`Script import file not found: ${fullPath}, skipping import`);
+                    }
+                    return exists;
+                });
+                if (validScriptImports.length > 0) {
+                    const scriptElements = [...new Set(validScriptImports)]
+                        .map(script => {
+                        // If script is a URL, use it as-is without prefix
+                        if (script.startsWith("http")) {
+                            return `<script  src="${script}"></script>`;
+                        }
+                        // For local scripts, use JSX syntax and ensure proper path joining
+                        const cleanScript = script.startsWith("/") ? script.substring(1) : script;
+                        return `<script defer  src={\`\${configs.appConfig.basePath}${cleanScript}\`}></script>`;
+                    })
+                        .join("\n");
+                    // Append new scripts before </head> instead of replacing
+                    const headCloseIndex = layoutContent.lastIndexOf("</head>");
+                    if (headCloseIndex !== -1) {
+                        const beforeHead = layoutContent.substring(0, headCloseIndex);
+                        const afterHead = layoutContent.substring(headCloseIndex);
+                        const updatedContent = `${beforeHead}
+                    ${scriptElements}
+            ${afterHead}`;
+                        fs_extra_1.default.writeFileSync(layoutPath, updatedContent);
+                    }
+                    else {
+                        // Fallback to original method if </head> not found
+                        const updatedContent = layoutContent.replace(/\s*<\/head>/, `${scriptElements}\n        </head>`);
+                        fs_extra_1.default.writeFileSync(layoutPath, updatedContent);
+                    }
+                }
+            }
+        }
+        if (NPM_PACKAGES.length) {
+            let data = fs_extra_1.default.readFileSync(`${this.projectPath}/package.json`, "utf-8");
+            const jsonData = JSON.parse(data);
+            NPM_PACKAGES.forEach(script => {
+                if (jsonData["dependencies"][script.match(/[\/]+(.*?)@\d/)[1]] &&
+                    semver_1.default.lt(jsonData["dependencies"][script.match(/[\/]+(.*?)@\d/)[1]], script.match(".*@(.*?)$")[1])) {
+                    console.log("adding new version " +
+                        script.match(".*@(.*?)$")[1] +
+                        "for script.match(/[\/]+(.*?)@\d/)![1] dependency");
+                    jsonData["dependencies"][script.match(/[\/]+(.*?)@\d/)[1]] =
+                        script.match(".*@(.*?)$")[1];
+                }
+                else {
+                    jsonData["dependencies"][script.match(/[\/]+(.*?)@\d/)[1]] =
+                        script.match(".*@(.*?)$")[1];
+                }
+            });
+            fs_extra_1.default.writeFileSync(`${this.projectPath}/package.json`, JSON.stringify(jsonData, null, 4));
+        }
+        return Promise.resolve({});
+    }
+    async resolveProjectType() {
+        this.isWaveApp = await this.projectService.getWmProjectType();
+        if (!this.isWaveApp)
+            return Promise.resolve({});
+        // CSS override import is now handled in gen-app-override-css.ts after the file is generated
+        // if it's waveApp replace the global.css file with foundation.css in the this.projectPath
+        const globalCSSPath = path_2.default.resolve(this.projectPath, "app/globals.css");
+        const layoutPath = path_2.default.resolve(this.projectPath, "app/layout.tsx");
+        const WaveLayoutPath = path_2.default.resolve(__dirname, "../templates/foundation/layout.tsx");
+        // Replace file import
+        const cssContent = '@import "@wavemaker-ai/app-runtime-wm-build/wmapp/styles/foundation/foundation.css";\n';
+        // Replace the first line of globals.css with cssContent
+        let existingCss = fs_extra_1.default.existsSync(globalCSSPath)
+            ? fs_extra_1.default.readFileSync(globalCSSPath, "utf-8").split("\n")
+            : [];
+        if (existingCss.length > 0) {
+            existingCss[0] = cssContent.trim();
+        }
+        else {
+            existingCss = [cssContent.trim()];
+        }
+        fs_extra_1.default.writeFileSync(globalCSSPath, existingCss.join("\n"), "utf-8");
+        const lines = fs_extra_1.default.readFileSync(layoutPath, "utf-8").split("\n");
+        // Remove the first line which is the import of global.css
+        if (lines.length > 0 && lines[0].includes("globals.css")) {
+            lines.splice(0, 1);
+        }
+        // Add the import of foundation.css after the first line
+        lines.splice(0, 0, 'import "@wavemaker-ai/app-runtime-wm-build/wmapp/styles/foundation/foundation.css";');
+        // Write the updated content back to layout
+        fs_extra_1.default.writeFileSync(layoutPath, lines.join("\n"), "utf-8");
+        // update layout
+        let layoutContent = fs_extra_1.default.readFileSync(WaveLayoutPath, "utf-8");
+        const isAppOverrideCssExist = await this.projectService
+            .getThemesFiles(this.isWaveApp)
+            .then(p => {
+            if (p && fs_extra_1.default.existsSync(path_2.default.join(p, "app.override.css"))) {
+                return true;
+            }
+            return false;
+        });
+        if (isAppOverrideCssExist) {
+            const lines = layoutContent.split("\n");
+            lines.splice(4, 0, 'import "public/design-tokens/app.override.css";');
+            layoutContent = lines.join("\n");
+        }
+        fs_extra_1.default.writeFileSync(layoutPath, layoutContent, "utf-8");
+    }
+    async setSecurityConfig() {
+        const securityConfig = await this.projectService.getAuthInfoFilePath();
+        if (securityConfig && securityConfig.csrfConfig) {
+            const envPath = `${this.projectPath}/.env`;
+            (0, utils_1.updateEnvFile)(envPath, {
+                NEXT_PUBLIC_XSRF_HEADER_NAME: securityConfig.csrfConfig.headerName,
+                NEXT_PUBLIC_XSRF_COOKIE_NAME: securityConfig.csrfConfig.cookieName,
+            });
+        }
+        return Promise.resolve();
+    }
+    generateFormatters() {
+        if (this.incBuilder) {
+            console.log(`Generating formatters.`);
+        }
+        return this.projectService.getFormatters().then(script => {
+            const code = FORMATTERS_TEMPLATE({
+                script: script,
+            });
+            return (0, utils_1.writeFile)(`${this.projectPath}/libs/extensions/formatters.js`, code);
+        });
+    }
+    async resolvei18nAndServiceDefsSource() {
+        const { i18nSource, serviceDefsSource } = await this.projectService.geti18nAndServiceDefsSource();
+        this.languageBundleSource = i18nSource;
+        this.serviceDefsSource = serviceDefsSource;
+        return Promise.resolve();
+    }
+    async copyWmProjectProperties() {
+        return this.projectService.getWmProjectPropertiesPath().then(sourceFile => {
+            const targetDir = path_2.default.resolve(this.projectPath + "/public/services/application");
+            const targetFile = path_2.default.join(targetDir, "wmProperties.js");
+            // Ensure target directory exists before copying or writing
+            fs_extra_1.default.mkdirSync(targetDir, { recursive: true });
+            if (fs_extra_1.default.existsSync(sourceFile)) {
+                fs_extra_1.default.copyFileSync(sourceFile, targetFile);
+                console.log("Wm project properties copied to wmProperties.js");
+            }
+            else {
+                fs_extra_1.default.writeFileSync(targetFile, "");
+                console.log("Warning: Empty file created at wmProperties.js");
+            }
+            return Promise.resolve();
+        });
+    }
+    generateApp(options) {
+        this.incBuilder || fs_extra_1.default.copySync(__dirname + "/../templates/project", this.projectPath);
+        return (this.generateOverrideCSS(options)
+            .then(() => this.resolveProjectType())
+            .then(() => this.setSecurityConfig())
+            .then(() => this.generatePagesAndPartials())
+            .then(() => this.generateAutoLayoutCSS())
+            .then(() => this.addIndexHtmlToLayout())
+            .then(() => this.resolvei18nAndServiceDefsSource())
+            .then(() => this.copyServiceDefs())
+            .then(() => this.copyWmProjectProperties())
+            .then(() => this.incBuilder && this.generateAllPrefabComponents())
+            .then(() => !this.incBuilder || this.incBuilder.isAppScriptModified())
+            .then(() => !this.incBuilder || this.incBuilder.isAppStyleModified())
+            .then((build) => (build && this.copyThemesFiles()))
+            .then((build) => (build && this.copyFavIcon()))
+            .then((build) => (build && this.copyResource()))
+            .then((build) => (build && this.generateAppStyles()))
+            .then(() => !this.incBuilder || this.incBuilder.isAppVariablesModified())
+            .then((build) => (build && this.generateAppVariables()))
+            .then(() => !this.incBuilder || this.incBuilder.isEntityModified())
+            .then((build) => (build && this.generateEntityMetadata()))
+            .then(() => !this.incBuilder || this.incBuilder.isFormatterModified())
+            .then((build) => (build && this.generateFormatters()))
+            .then(() => !this.incBuilder || this.incBuilder.isi18nModified())
+            .then((build) => (build && this.copyi18nFiles()))
+            .then(() => !this.incBuilder || this.incBuilder.isi18nModified())
+            .then((build) => (build && this.resolvePackage()))
+            .then(() => !this.incBuilder || this.incBuilder.isFontConfigModified())
+            .then((build) => (build && this.generateFontConfig()))
+            .then(() => {
+            if (this.incBuilder) {
+                const components = this.incBuilder.getWMXModifiedComponents();
+                return Promise.all(components.map((c) => this.wmxGenerator.generate(c, true)));
+            }
+        })
+            .then(() => !this.incBuilder)
+            // .then(build => (build && this.prettify()) as any)
+            .then(() => console.log("code generated at " + this.projectPath)));
+    }
+    generateFragment(name) {
+        let pageConfigs = null;
+        return (this.projectService
+            .getPageConfigs()
+            .then(_pageConfigs => {
+            pageConfigs = _pageConfigs;
+            const info = pageConfigs.find(config => config.name === name);
+            if (info) {
+                if (info.type === "PAGE") {
+                    return this.generatePageComponent(info.name);
+                }
+                if (this.isPartial(info.type)) {
+                    return this.generatePartialComponent(name);
+                }
+            }
+        })
+            .then(() => this.generatePageConfig(pageConfigs))
+            .then(() => this.generatePartialConfig(pageConfigs))
+            // .then(() => this.prettify(`**/${name}/**/*.js`))
+            .then(() => console.log("code generated at " + this.projectPath)));
+    }
+}
+exports.default = AppGenerator;
+//# sourceMappingURL=app.generator.js.map