@sap-ux/fiori-migration-writer 0.0.0-stage → 0.0.2

package/dist/ProjectMigrator.js

@@ -0,0 +1,359 @@
+import { FioriElementsVersion, FileName } from './project-spec-types.js';
+import { determineMessage, readFile, updateFile } from './utils/index.js';
+import { createMemFsEditor, getCurrentEditor, runWithEditor, exists } from './utils/fs-adapter.js';
+import { commitFileSystemChanges } from './files/file-system.js';
+import { ui5VersionRequestInfo } from '@sap-ux/ui5-info';
+import { getAppProgrammingLanguage } from '@sap-ux/project-access';
+import { enableTypescript, ui5TSSupport } from '@sap-ux/ui5-application-writer';
+import { UI5Config } from '@sap-ux/ui5-config';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+// Migration-specific functions
+import { determineSourceTemplateType, checkForErrors, createMigrationErrorMessage, prepareConfigurationData, setupProjectStructure, generateAppSettings, applyAllTemplates, postProcessMigration } from './migration-process/index.js';
+// File operations
+import { copyAdaptationFiles, copyLibraryFiles } from './files/index.js';
+// Template functions
+import { assembleTemplateData } from './template/index.js';
+// Project functions
+import { loadOrFetchProjectInfo, validateProjectForMigration } from './project/index.js';
+// Data functions
+import { resolveUI5VersionsForMigration } from './data/index.js';
+import { MigrationTypes } from './utils/constants.js';
+import { hasStore } from './types/mem-fs-types.js';
+import { i18nText, initI18n } from './i18n.js';
+export class ProjectMigrator {
+    // Implementation
+    static async migrate(
+    // NOSONAR - Implementation must support both overload signatures
+    projectRootOrOptions, baseUri, ui5SnapshotUrl, importProjectInfo, vscode, internalToggle, fs, strict) {
+        // Convert old signature to options object if called with positional parameters
+        const options = typeof projectRootOrOptions === 'string'
+            ? {
+                projectRoot: projectRootOrOptions,
+                baseUri: baseUri ?? '',
+                ui5SnapshotUrl: ui5SnapshotUrl ?? '',
+                importProjectInfo,
+                vscode,
+                internalToggle,
+                fs,
+                strict
+            }
+            : projectRootOrOptions;
+        const { projectRoot, baseUri: baseUriOpt, ui5SnapshotUrl: ui5SnapshotUrlOpt, importProjectInfo: importProjectInfoOpt, vscode: vscodeOpt, internalToggle: internalToggleOpt = false, fs: fsOpt, strict: strictOpt = false } = options;
+        // Create a new isolated editor instance for this migration if not provided
+        // This enables concurrent migrations without shared state corruption
+        const ownsEditor = !fsOpt;
+        const editor = fsOpt ?? createMemFsEditor();
+        await initI18n();
+        // Run migration within editor context so all functions have access to it
+        const migrationResult = await runWithEditor(editor, async () => {
+            let messages = [];
+            let result = false;
+            try {
+                // Load or fetch project information
+                const { projectInfo, messages: projectInfoMessages } = await loadOrFetchProjectInfo(projectRoot, importProjectInfoOpt);
+                messages = messages.concat(projectInfoMessages);
+                projectInfo.baseUri = baseUriOpt;
+                // Resolve UI5 versions for migration
+                const ui5Versions = await resolveUI5VersionsForMigration(projectInfo, ui5SnapshotUrlOpt);
+                projectInfo.localUI5Version = ui5Versions?.[0]?.version;
+                if (/^(snapshot(-untested)?)?$/i.test(projectInfo.ui5Version?.trim() ?? '')) {
+                    projectInfo.ui5Version = projectInfo.localUI5Version ?? '';
+                }
+                // Validate project is suitable for migration (not a Fiori app in CAP project)
+                await validateProjectForMigration(projectRoot);
+                if (projectInfo &&
+                    (projectInfo.isSAPApp ||
+                        projectInfo.FEVersion === FioriElementsVersion.v2 ||
+                        projectInfo.FEVersion === FioriElementsVersion.v4 ||
+                        projectInfo.type === MigrationTypes.projectExtension) &&
+                    checkForErrors(messages)) {
+                    // V2 is supported (checkForErrors returns true if no ERROR-level messages)
+                    const { messages: copyMessages, result: isSuccess } = await this.copyCommonFiles(projectInfo, vscodeOpt, ui5SnapshotUrlOpt, internalToggleOpt, strictOpt);
+                    messages = messages.concat(copyMessages);
+                    result = isSuccess;
+                }
+                else if (projectInfo.type === MigrationTypes.library) {
+                    const { fs: updatedFs, messages: copyMessages, result: isSuccess } = await this.copyLibraryFiles(projectInfo);
+                    messages = messages.concat(copyMessages);
+                    result = isSuccess;
+                    // Update editor to the one returned from copyLibraryFiles
+                    return { fs: updatedFs, result, messages };
+                }
+                else if (projectInfo.uiAdaptation) {
+                    const { fs: updatedFs, messages: copyMessages, result: isSuccess } = await this.copyAdaptationFiles(projectInfo, ui5SnapshotUrlOpt);
+                    messages = messages.concat(copyMessages);
+                    result = isSuccess;
+                    // Update editor to the one returned from copyAdaptationFiles
+                    return { fs: updatedFs, result, messages };
+                }
+                else {
+                    messages.push({ type: 'ERROR', description: i18nText('ERROR_FAILED_TO_GET_PROJECT_INFO') });
+                }
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(String(e));
+                const useMessage = typeof e === 'object' && e !== null && 'useMessage' in e ? Boolean(e.useMessage) : false;
+                messages.push({
+                    type: 'ERROR',
+                    description: `Error during migration: ${determineMessage(error, undefined, useMessage)}`
+                });
+            }
+            // Return fs editor for caller to commit
+            // This matches the pattern used by other open-ux-tools writers
+            return { fs: editor, result, messages };
+        });
+        if (ownsEditor && migrationResult.result) {
+            try {
+                await commitFileSystemChanges(migrationResult.fs);
+            }
+            catch (error) {
+                migrationResult.result = false;
+                migrationResult.messages.push({
+                    type: 'ERROR',
+                    description: `Error committing migration: ${error instanceof Error ? error.message : String(error)}`
+                });
+            }
+        }
+        return migrationResult;
+    }
+    /**
+     * Copy files from templates into the project
+     * Orchestrates the migration process through distinct phases
+     *
+     * @param projectInfo - Project information
+     * @param vscode - VS Code context
+     * @param ui5SnapshotUrl - UI5 snapshot URL
+     * @param internalToggle - Internal feature toggle
+     * @param strict - Enable strict validation mode (WARNINGs become ERRORs for critical issues)
+     * @returns Migration result with status and messages
+     */
+    static async copyCommonFiles(projectInfo, vscode, ui5SnapshotUrl, internalToggle = false, strict = false) {
+        const messages = [];
+        const { isSAPApp = false, rootPath, destination, neoappDestinations, firstNeoAppDestination } = projectInfo;
+        try {
+            // Detect TypeScript project
+            const isTypeScriptApp = await ProjectMigrator.detectTypeScriptApp(rootPath, projectInfo.webappPath);
+            // Prepare configuration data
+            const configData = await prepareConfigurationData(projectInfo, projectInfo.ui5Version, isTypeScriptApp);
+            // Phase 1: Setup project structure
+            const { webappPath, keepIndex } = await setupProjectStructure(projectInfo, rootPath);
+            projectInfo.webappPath = webappPath;
+            // Phase 2: Assemble template data
+            const templateContext = await assembleTemplateData({
+                projectInfo,
+                rootPath,
+                projectData: configData.projectData,
+                serviceData: configData.serviceData,
+                config: {
+                    semanticObject: configData.semanticObject,
+                    fullyQualifiedProjectName: configData.fullyQualifiedProjectName,
+                    fullyQualifiedProjectNameAMD: configData.fullyQualifiedProjectNameAMD,
+                    sapUiLibs: configData.sapUiLibs,
+                    ui5Theme: configData.ui5Theme,
+                    projectUI5Version: configData.projectUI5Version,
+                    baseUiLibsStr: configData.baseUiLibsStr,
+                    supportedThemes: configData.supportedThemes,
+                    sapClientParam: configData.sapClientParam
+                },
+                moduleInfo: {
+                    moduleName: projectInfo.moduleName,
+                    moduleDescription: projectInfo.moduleDescription,
+                    destination
+                },
+                ui5Config: {
+                    projectUI5Version: configData.projectUI5Version,
+                    localUI5Version: projectInfo.localUI5Version,
+                    ui5Version: projectInfo.ui5Version,
+                    ui5SnapshotUrl,
+                    ui5VersionRequestInfo,
+                    ui5Theme: configData.ui5Theme
+                },
+                backendConfig: {
+                    baseUri: projectInfo.baseUri ?? '',
+                    scp: projectInfo.scp,
+                    destination,
+                    sapClient: projectInfo.sapClient
+                },
+                libraryConfig: {
+                    sapLibs: projectInfo.sapLibs ?? '',
+                    baseUiLibsStr: configData.baseUiLibsStr,
+                    supportedThemes: configData.supportedThemes
+                },
+                flags: {
+                    keepIndex,
+                    internalToggle,
+                    hasRootIntent: projectInfo.hasRootIntent,
+                    floorPlan: projectInfo.floorPlan
+                }
+            });
+            // Phase 3: Generate app settings
+            const sourceTemplateType = determineSourceTemplateType(projectInfo, MigrationTypes);
+            await generateAppSettings({
+                rootPath,
+                templateData: templateContext.templateData,
+                destination,
+                webappPath,
+                messages,
+                sourceTemplateType,
+                hasDataSource: templateContext.hasDataSource,
+                neoappDestinations,
+                sourceTemplateTest: projectInfo.sourceTemplate,
+                firstNeoAppDestination,
+                strict
+            });
+            // Phase 4: Apply all templates
+            await applyAllTemplates({
+                projectInfo,
+                rootPath,
+                templateData: templateContext.templateData,
+                hasDataSource: templateContext.hasDataSource,
+                finalKeepIndex: templateContext.keepIndex,
+                internalToggle,
+                ui5Version: projectInfo.ui5Version,
+                isSAPApp,
+                appIntent: templateContext.appIntent ?? '',
+                appMockIntent: templateContext.appMockIntent
+            });
+            // Phase 5: Post-processing
+            await postProcessMigration({
+                projectInfo,
+                rootPath,
+                manifestJSON: templateContext.manifestJSON,
+                vscode,
+                appIntent: templateContext.appIntent,
+                appMockIntent: templateContext.appMockIntent,
+                flpSandboxAvailable: templateContext.flpSandboxAvailable,
+                messages,
+                strict
+            });
+            // Phase 6: TypeScript setup (if TypeScript app detected)
+            if (isTypeScriptApp) {
+                const tsMessages = await ProjectMigrator.setupTypeScript(rootPath);
+                messages.push(...tsMessages);
+            }
+            return { result: checkForErrors(messages), messages };
+        }
+        catch (e) {
+            return {
+                result: false,
+                messages: [...messages, { type: 'ERROR', description: createMigrationErrorMessage(e) }]
+            };
+        }
+    }
+    /**
+     * Copy files from templates into the project
+     *
+     * @param projectInfo
+     * @param snapshotUrl
+     */
+    static async copyAdaptationFiles(projectInfo, snapshotUrl) {
+        return copyAdaptationFiles(projectInfo, snapshotUrl, undefined);
+    }
+    /**
+     * Copy files from templates into the project
+     *
+     * @param projectInfo
+     */
+    static async copyLibraryFiles(projectInfo) {
+        return copyLibraryFiles(projectInfo);
+    }
+    /**
+     * Configures a downloaded TypeScript app for local development.
+     * Generates tsconfig.json and TypeScript devDependencies via {@link enableTypescript},
+     * then patches ui5-local.yaml and ui5-mock.yaml with the transpile middleware and task.
+     *
+     * @param rootPath - The project root path.
+     * @returns Messages to surface to the user after setup.
+     */
+    static async setupTypeScript(rootPath) {
+        const messages = [];
+        try {
+            await enableTypescript(rootPath, getCurrentEditor());
+        }
+        catch (err) {
+            messages.push({
+                type: 'ERROR',
+                description: `Error enabling TypeScript: ${err instanceof Error ? err.message : String(err)}`
+            });
+            return messages;
+        }
+        // Check and update ui5*.yaml files sequentially - order doesn't matter but list is small
+        for (const yamlName of [FileName.UI5LocalYaml, FileName.UI5MockYaml]) {
+            const yamlPath = join(rootPath, yamlName);
+            if (await exists(yamlPath)) {
+                // NOSONAR - Only 2 files, acceptable sequential check
+                // readFile and updateFile are sync mem-fs operations
+                const yamlContent = readFile(yamlPath);
+                const yamlConfig = await UI5Config.newInstance(yamlContent); // NOSONAR - Sequential YAML parsing required
+                yamlConfig.addCustomMiddleware([ui5TSSupport.middleware]);
+                yamlConfig.addCustomTasks([ui5TSSupport.task]);
+                updateFile(yamlPath, yamlConfig.toString());
+            }
+        }
+        messages.push({
+            type: 'WARNING',
+            description: i18nText('TYPESCRIPT_STRICT_MODE_WARNING')
+        });
+        return messages;
+    }
+    /**
+     * Detects whether the project is a TypeScript application.
+     * First attempts detection via {@link getAppProgrammingLanguage}, which relies on tsconfig.json being present.
+     * Falls back to scanning the webapp folder for .ts files directly, since after a download from ABAP
+     * the project will not yet have a tsconfig.json — it is added as part of the migration itself.
+     *
+     * @param rootPath - The project root path.
+     * @param webappPath - The relative path to the webapp folder.
+     * @returns True if the project contains TypeScript source files.
+     */
+    static async detectTypeScriptApp(rootPath, webappPath) {
+        const webappFullPath = join(rootPath, webappPath);
+        // Try getAppProgrammingLanguage first (needs tsconfig.json and package.json)
+        let isTypeScript = false;
+        try {
+            isTypeScript = (await getAppProgrammingLanguage(rootPath)) === 'TypeScript';
+        }
+        catch (error) {
+            // Expected: getAppProgrammingLanguage may fail for legacy projects without package.json
+            // Will fall back to scanning for .ts files below
+        }
+        if (isTypeScript) {
+            return true;
+        }
+        return ProjectMigrator.webappHasTypeScriptFile(webappFullPath);
+    }
+    /**
+     * Scans the webapp folder for a TypeScript source file (.ts, excluding .d.ts).
+     * During migration the downloaded files live in the uncommitted mem-fs editor, so when an
+     * editor with a store is in context the mem-fs store is scanned; otherwise the real disk is read.
+     *
+     * @param webappFullPath - Absolute path to the webapp folder.
+     * @returns True if a non-declaration .ts file is present under the webapp folder.
+     */
+    static async webappHasTypeScriptFile(webappFullPath) {
+        const isTypeScriptFile = (filePath) => filePath.endsWith('.ts') && !filePath.endsWith('.d.ts');
+        const editor = getCurrentEditor();
+        if (editor && hasStore(editor)) {
+            // mem-fs mode: scan staged files under the webapp folder (paths use forward slashes)
+            const normalizedPrefix = webappFullPath.replaceAll('\\', '/').replace(/\/?$/, '/');
+            let found = false;
+            editor.store.each((file) => {
+                if (file.state === 'deleted') {
+                    return;
+                }
+                const normalizedFilePath = file.path.replaceAll('\\', '/');
+                if (normalizedFilePath.startsWith(normalizedPrefix) && isTypeScriptFile(normalizedFilePath)) {
+                    found = true;
+                }
+            });
+            return found;
+        }
+        // No editor context: scan the real filesystem
+        if (!(await exists(webappFullPath))) {
+            return false;
+        }
+        return (await readdir(webappFullPath, { recursive: true })).some((f) => typeof f === 'string' && isTypeScriptFile(f));
+    }
+}
+//# sourceMappingURL=ProjectMigrator.js.map

package/dist/adapters/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapters for open-ux-tools packages
+ *
+ * These adapters wrap standard @sap-ux packages to provide migration-specific
+ * functionality while following open-ux-tools patterns.
+ */
+export * from './ui5-config-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.js

@@ -0,0 +1,8 @@
+/**
+ * Adapters for open-ux-tools packages
+ *
+ * These adapters wrap standard @sap-ux packages to provide migration-specific
+ * functionality while following open-ux-tools patterns.
+ */
+export * from './ui5-config-adapter.js';
+//# sourceMappingURL=index.js.map

package/dist/adapters/ui5-config-adapter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Adapter for @sap-ux/ui5-config package
+ *
+ * This adapter wraps the @sap-ux/ui5-config builder to generate ui5.yaml
+ * files using the standard open-ux-tools package instead of custom templates.
+ *
+ * Phase 1 of refactoring: Replace custom ui5Config.ts with this adapter.
+ */
+import type { TemplateData, NeoappDestination, Message } from '../types.js';
+/**
+ * Options for generating UI5 YAML content
+ */
+export interface UI5YamlOptions {
+    /** Migration template data containing project configuration */
+    templateData: TemplateData;
+    /** Optional array of neo-app destinations */
+    neoappDestinations?: NeoappDestination[];
+    /** Array to collect warning messages */
+    messages?: Message[];
+    /** Selected destination name */
+    destination?: string;
+    /** First neo-app destination name */
+    firstNeoAppDestination?: string;
+    /** Optional webapp path for builder configuration */
+    webappPath?: string;
+    /** Whether to set UI5 version in proxy middleware */
+    setUI5Version?: boolean;
+    /** Enable strict validation mode (WARNING becomes ERROR) */
+    strict?: boolean;
+}
+/**
+ * Generate ui5.yaml content using @sap-ux/ui5-config builder
+ *
+ * @param options - UI5 YAML generation options
+ * @returns Promise resolving to ui5.yaml content as string
+ */
+export declare function generateUI5YamlContent(options: UI5YamlOptions): Promise<string>;
+/**
+ * Generate ui5-local.yaml content using @sap-ux/ui5-config builder
+ *
+ * ui5-local.yaml differs from ui5.yaml in that it:
+ * - Does not set UI5 version in proxy middleware (relies on local framework)
+ * - May include sap-fe-mockserver middleware for mock data
+ *
+ * Note: Both ui5.yaml and ui5-local.yaml include framework section with SAPUI5 libraries
+ * when localUI5Version and sapUiLibs are provided. The @sap-ux/ui5-config library
+ * auto-adds the framework section based on these settings.
+ *
+ * @param options - UI5 YAML generation options (setUI5Version is ignored for local yaml)
+ * @returns Promise resolving to ui5-local.yaml content as string
+ */
+export declare function generateUI5LocalYamlContent(options: UI5YamlOptions): Promise<string>;
+/**
+ * Generate ui5-mock.yaml content using @sap-ux/ui5-config builder
+ *
+ * @param templateData - Migration template data containing project configuration
+ * @param webappPath - Optional webapp path for builder configuration
+ * @param setUI5Version - Whether to set UI5 version in proxy middleware
+ * @returns Promise resolving to ui5-mock.yaml content as string
+ */
+export declare function generateUI5MockYamlContent(templateData: TemplateData, webappPath?: string, setUI5Version?: boolean): Promise<string>;
+//# sourceMappingURL=ui5-config-adapter.d.ts.map

package/dist/adapters/ui5-config-adapter.js

@@ -0,0 +1,232 @@
+/**
+ * Adapter for @sap-ux/ui5-config package
+ *
+ * This adapter wraps the @sap-ux/ui5-config builder to generate ui5.yaml
+ * files using the standard open-ux-tools package instead of custom templates.
+ *
+ * Phase 1 of refactoring: Replace custom ui5Config.ts with this adapter.
+ */
+import { UI5Config } from '@sap-ux/ui5-config';
+import { parse, stringify } from 'yaml';
+import { setWebappPath, setAppreloadPath } from '../data/yaml.js';
+import { updateNeoYamlBackends, updateYamlBackends } from '../config/backend.js';
+import { buildMainBackend, buildProxyConfig, buildPreviewMiddleware } from './ui5-config-helpers.js';
+/**
+ * Add sap-fe-mockserver middleware to the YAML configuration
+ *
+ * @param orderedYaml - YAML object to modify
+ * @param templateData - Template data with mockserver configuration
+ */
+function addMockserverMiddleware(orderedYaml, templateData) {
+    if (!orderedYaml.server) {
+        orderedYaml.server = { customMiddleware: [] };
+    }
+    if (!orderedYaml.server.customMiddleware) {
+        orderedYaml.server.customMiddleware = [];
+    }
+    const mockserverMiddleware = {
+        name: 'sap-fe-mockserver',
+        beforeMiddleware: 'fiori-tools-proxy',
+        configuration: {
+            service: {
+                urlBasePath: templateData.ui5Yaml?.servicePath,
+                name: templateData.ui5Yaml?.serviceName ?? '',
+                metadataXmlPath: templateData.ui5Yaml?.metadataXmlPath || '',
+                mockdataRootPath: templateData.ui5Yaml?.mockdataRootPath || '',
+                generateMockData: templateData.ui5Yaml?.generateMockData
+            }
+        }
+    };
+    // Find index of fiori-tools-proxy and insert before it
+    const proxyIndex = orderedYaml.server.customMiddleware.findIndex((mw) => mw.name === 'fiori-tools-proxy');
+    if (proxyIndex >= 0) {
+        orderedYaml.server.customMiddleware.splice(proxyIndex, 0, mockserverMiddleware);
+    }
+    else {
+        // If proxy not found, add at beginning
+        orderedYaml.server.customMiddleware.unshift(mockserverMiddleware);
+    }
+}
+/**
+ * Build backend configuration from template data and neo-app destinations
+ *
+ * @param templateData - Template data with backend configuration
+ * @param neoappDestinations - Optional array of neo-app destinations
+ * @param messages - Array to collect warning messages
+ * @param destination - Selected destination name
+ * @param firstNeoAppDestination - First neo-app destination name
+ * @param strict - Enable strict validation mode
+ * @returns Array of backend configurations
+ */
+function buildBackendConfigs(templateData, neoappDestinations, messages, destination, firstNeoAppDestination, strict = false) {
+    let backends = [];
+    // Add main backend if configured
+    const mainBackend = buildMainBackend(templateData);
+    if (mainBackend) {
+        backends.push(mainBackend);
+    }
+    // Handle neo-app destinations if provided (uses existing helper logic)
+    if (neoappDestinations && neoappDestinations.length > 0) {
+        const tempBackendConfigs = updateNeoYamlBackends(neoappDestinations, backends, templateData, messages || [], destination || '', firstNeoAppDestination, strict);
+        backends = tempBackendConfigs;
+    }
+    // Apply additional backend processing (uses existing helper logic)
+    if (backends.length > 0) {
+        const proxyConfigTemp = { backend: backends };
+        const processed = updateYamlBackends(proxyConfigTemp, templateData);
+        backends = processed.backend;
+    }
+    return backends;
+}
+/**
+ * Generate ui5.yaml content using @sap-ux/ui5-config builder
+ *
+ * @param options - UI5 YAML generation options
+ * @returns Promise resolving to ui5.yaml content as string
+ */
+export async function generateUI5YamlContent(options) {
+    const { templateData, neoappDestinations, messages, destination, firstNeoAppDestination, webappPath, setUI5Version, strict = false } = options;
+    const config = await UI5Config.newInstance('', { validateSchema: false });
+    // Set metadata and type
+    config.setMetadata({
+        name: templateData.ui5Yaml?.name?.toLowerCase() || templateData.project.name?.toLowerCase() || 'app'
+    });
+    config.setType('application');
+    // Build backend configuration using helpers
+    const backends = buildBackendConfigs(templateData, neoappDestinations, messages, destination, firstNeoAppDestination, strict);
+    // Add fiori-tools-proxy middleware with all backends
+    const proxyConfig = buildProxyConfig(backends, templateData, setUI5Version);
+    config.addFioriToolsProxyMiddleware(proxyConfig);
+    // Add fiori-tools-appreload middleware
+    config.addFioriToolsAppReloadMiddleware();
+    // Add fiori-tools-preview middleware if configured
+    const previewMiddleware = buildPreviewMiddleware(templateData);
+    if (previewMiddleware) {
+        config.addCustomMiddleware(previewMiddleware);
+    }
+    const yamlContent = config.toString();
+    // Post-process: Add specVersion 4.0 (UI5Config doesn't set this)
+    const yamlJson = parse(yamlContent);
+    // Add specVersion at the top
+    const orderedYaml = { specVersion: '4.0' };
+    Object.keys(yamlJson).forEach((key) => {
+        orderedYaml[key] = yamlJson[key];
+    });
+    // Apply webappPath if provided
+    if (webappPath) {
+        setWebappPath(orderedYaml, webappPath);
+        setAppreloadPath(orderedYaml, webappPath);
+    }
+    return stringify(orderedYaml);
+}
+/**
+ * Generate ui5-local.yaml content using @sap-ux/ui5-config builder
+ *
+ * ui5-local.yaml differs from ui5.yaml in that it:
+ * - Does not set UI5 version in proxy middleware (relies on local framework)
+ * - May include sap-fe-mockserver middleware for mock data
+ *
+ * Note: Both ui5.yaml and ui5-local.yaml include framework section with SAPUI5 libraries
+ * when localUI5Version and sapUiLibs are provided. The @sap-ux/ui5-config library
+ * auto-adds the framework section based on these settings.
+ *
+ * @param options - UI5 YAML generation options (setUI5Version is ignored for local yaml)
+ * @returns Promise resolving to ui5-local.yaml content as string
+ */
+export async function generateUI5LocalYamlContent(options) {
+    const { templateData, neoappDestinations, messages, destination, firstNeoAppDestination, webappPath, strict = false } = options;
+    const config = await UI5Config.newInstance('', { validateSchema: false });
+    // Set metadata and type
+    config.setMetadata({
+        name: templateData.ui5Yaml?.name?.toLowerCase() || templateData.project.name?.toLowerCase() || 'app'
+    });
+    config.setType('application');
+    // Add framework section with SAPUI5 libraries (ui5-local.yaml specific)
+    if (templateData.project.localUI5Version && templateData.ui5Yaml?.sapUiLibs) {
+        const libraries = [...templateData.ui5Yaml.sapUiLibs];
+        const theme = templateData.ui5Yaml?.ui5Theme || 'sap_horizon';
+        // Note: addUI5Framework automatically appends the theme library based on the theme parameter,
+        // so we don't need to manually add it to the libraries array
+        config.addUI5Framework('SAPUI5', templateData.project.localUI5Version, libraries, theme);
+    }
+    // Build backend configuration using helpers
+    const backends = buildBackendConfigs(templateData, neoappDestinations, messages, destination, firstNeoAppDestination, strict);
+    // Add fiori-tools-proxy middleware with all backends (no UI5 version, no ui5 proxy section for local)
+    const proxyConfig = {
+        ignoreCertErrors: false,
+        backend: backends
+    };
+    config.addFioriToolsProxyMiddleware(proxyConfig);
+    // Add fiori-tools-appreload middleware
+    config.addFioriToolsAppReloadMiddleware();
+    // Add fiori-tools-preview middleware if configured
+    const previewMiddleware = buildPreviewMiddleware(templateData);
+    if (previewMiddleware) {
+        config.addCustomMiddleware(previewMiddleware);
+    }
+    const yamlContent = config.toString();
+    // Parse and post-process
+    const yamlJson = parse(yamlContent);
+    // Add specVersion at the top
+    const orderedYaml = { specVersion: '4.0' };
+    Object.keys(yamlJson).forEach((key) => {
+        orderedYaml[key] = yamlJson[key];
+    });
+    // Add sap-fe-mockserver middleware if generateMockData is defined (ui5-local.yaml specific)
+    if (templateData.ui5Yaml?.generateMockData !== undefined && templateData.ui5Yaml?.servicePath) {
+        addMockserverMiddleware(orderedYaml, templateData);
+    }
+    // Apply webappPath if provided
+    if (webappPath) {
+        setWebappPath(orderedYaml, webappPath);
+        setAppreloadPath(orderedYaml, webappPath);
+    }
+    return stringify(orderedYaml);
+}
+/**
+ * Generate ui5-mock.yaml content using @sap-ux/ui5-config builder
+ *
+ * @param templateData - Migration template data containing project configuration
+ * @param webappPath - Optional webapp path for builder configuration
+ * @param setUI5Version - Whether to set UI5 version in proxy middleware
+ * @returns Promise resolving to ui5-mock.yaml content as string
+ */
+export async function generateUI5MockYamlContent(templateData, webappPath, setUI5Version) {
+    const config = await UI5Config.newInstance('', { validateSchema: false });
+    // Set metadata and type
+    config.setMetadata({
+        name: templateData.ui5Yaml?.name?.toLowerCase() || templateData.project.name?.toLowerCase() || 'app'
+    });
+    config.setType('application');
+    // Add fiori-tools-proxy middleware with UI5 version if provided
+    const proxyConfig = {
+        ignoreCertErrors: false,
+        backend: [],
+        ui5: {
+            path: ['/resources', '/test-resources'],
+            url: templateData.ui5Yaml?.ui5Url || ''
+        }
+    };
+    // Add UI5 version to proxy if provided and setUI5Version is true
+    if (setUI5Version && templateData.ui5Yaml?.ui5Version) {
+        proxyConfig.ui5.version = templateData.ui5Yaml.ui5Version;
+    }
+    config.addFioriToolsProxyMiddleware(proxyConfig);
+    // Add fiori-tools-appreload middleware
+    config.addFioriToolsAppReloadMiddleware();
+    const yamlContent = config.toString();
+    // Post-process: Add specVersion and webappPath
+    const yamlJson = parse(yamlContent);
+    // Add specVersion at the top
+    const orderedYaml = { specVersion: '4.0' };
+    Object.keys(yamlJson).forEach((key) => {
+        orderedYaml[key] = yamlJson[key];
+    });
+    // Apply webappPath if provided
+    if (webappPath) {
+        setWebappPath(orderedYaml, webappPath);
+        setAppreloadPath(orderedYaml, webappPath);
+    }
+    return stringify(orderedYaml);
+}
+//# sourceMappingURL=ui5-config-adapter.js.map