@sap-ux/fiori-migration-writer 0.0.5 → 0.0.6

package/dist/config/backend-i18n.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Result of backend and i18n configuration extraction
  */
@@ -12,6 +13,7 @@ export interface BackendAndI18nConfigResult {
  * Extract backend configuration and app title from i18n properties
  * Combines backend settings from UI5 backend config with i18n app title extraction
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @param webappPath - Webapp path within the project
  * @param getFirstBackend - Function to get the first backend configuration
@@ -21,10 +23,29 @@ export interface BackendAndI18nConfigResult {
  * @param existingSapClient - Existing sapClient value
  * @returns Backend and i18n configuration result
  */
-export declare function extractBackendAndI18nConfig(projectRoot: string, webappPath: string, getFirstBackend: (projectRoot: string) => {
-    destination?: string;
-    scp?: boolean;
-    url?: string;
-    sapClient?: string;
-}, existingDestination: string, existingScp: boolean | undefined, existingHostname: string, existingSapClient: string): Promise<BackendAndI18nConfigResult>;
+/**
+ * Options for extractBackendAndI18nConfig
+ */
+export interface ExtractBackendAndI18nConfigOptions {
+    fs: Editor;
+    projectRoot: string;
+    webappPath: string;
+    getFirstBackend: (projectRoot: string) => {
+        destination?: string;
+        scp?: boolean;
+        url?: string;
+        sapClient?: string;
+    };
+    existingDestination: string;
+    existingScp: boolean | undefined;
+    existingHostname: string;
+    existingSapClient: string;
+}
+/**
+ * Extract backend configuration and app title from i18n.
+ *
+ * @param options - Backend/i18n extraction options
+ * @returns Backend and i18n configuration result
+ */
+export declare function extractBackendAndI18nConfig(options: ExtractBackendAndI18nConfigOptions): Promise<BackendAndI18nConfigResult>;
 //# sourceMappingURL=backend-i18n.d.ts.map

package/dist/config/backend-i18n.js

@@ -5,19 +5,13 @@ import { join } from 'node:path';
 import { fileExists } from '../utils/index.js';
 import { getPropertiesI18nBundle } from '@sap-ux/i18n';
 /**
- * Extract backend configuration and app title from i18n properties
- * Combines backend settings from UI5 backend config with i18n app title extraction
+ * Extract backend configuration and app title from i18n.
  *
- * @param projectRoot - Root path of the project
- * @param webappPath - Webapp path within the project
- * @param getFirstBackend - Function to get the first backend configuration
- * @param existingDestination - Existing destination value
- * @param existingScp - Existing scp value
- * @param existingHostname - Existing hostname value
- * @param existingSapClient - Existing sapClient value
+ * @param options - Backend/i18n extraction options
  * @returns Backend and i18n configuration result
  */
-export async function extractBackendAndI18nConfig(projectRoot, webappPath, getFirstBackend, existingDestination, existingScp, existingHostname, existingSapClient) {
+export async function extractBackendAndI18nConfig(options) {
+    const { fs, projectRoot, webappPath, getFirstBackend, existingDestination, existingScp, existingHostname, existingSapClient } = options;
     // Get backend configuration
     const ui5Backend = getFirstBackend(projectRoot);
     const destination = ui5Backend?.destination ?? existingDestination;
@@ -27,7 +21,7 @@ export async function extractBackendAndI18nConfig(projectRoot, webappPath, getFi
     // Extract app title from i18n
     let appTitle = '';
     const i18Path = join(projectRoot, webappPath, 'i18n/i18n.properties');
-    if (await fileExists(i18Path)) {
+    if (fileExists(fs, i18Path)) {
         try {
             const i18nProperties = await getPropertiesI18nBundle(i18Path);
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment

package/dist/config/flp/intent.d.ts

@@ -1,6 +1,7 @@
 /**
  * Helper functions for FLP (Fiori Launchpad) sandbox and app intent generation
  */
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo } from '../../types.js';
 /**
  * Check if FLP sandbox is available
@@ -9,12 +10,13 @@ import type { ImportProjectInfo } from '../../types.js';
  * - OR it's a Fiori Elements V2/V4 project (will be generated)
  * - OR it's a SAP app
  *
+ * @param fs
  * @param rootPath
  * @param webappPath
  * @param FEVersion
  * @param isSAPApp
  */
-export declare function checkFlpSandboxAvailability(rootPath: string, webappPath: string, FEVersion: string | undefined, isSAPApp: boolean): Promise<boolean>;
+export declare function checkFlpSandboxAvailability(fs: Editor, rootPath: string, webappPath: string, FEVersion: string | undefined, isSAPApp: boolean): boolean;
 /**
  * Generate app intent based on project configuration and semantic object
  * App intent format depends on FE version and whether FLP sandbox is available
@@ -39,12 +41,13 @@ export declare function generateAppMockIntent(semanticObject: string, flpSandbox
  * Generate all FLP-related intents and availability flags
  * Consolidates FLP sandbox checking and intent generation
  *
+ * @param fs
  * @param projectInfo
  * @param semanticObject
  */
-export declare function prepareFlpConfiguration(projectInfo: ImportProjectInfo, semanticObject: string): Promise<{
+export declare function prepareFlpConfiguration(fs: Editor, projectInfo: ImportProjectInfo, semanticObject: string): {
     flpSandboxAvailable: boolean;
     appIntent: string;
     appMockIntent: string;
-}>;
+};
 //# sourceMappingURL=intent.d.ts.map

package/dist/config/flp/intent.js

@@ -12,15 +12,16 @@ import { MigrationTypes } from '../../utils/constants.js';
  * - OR it's a Fiori Elements V2/V4 project (will be generated)
  * - OR it's a SAP app
  *
+ * @param fs
  * @param rootPath
  * @param webappPath
  * @param FEVersion
  * @param isSAPApp
  */
-export async function checkFlpSandboxAvailability(rootPath, webappPath, FEVersion, isSAPApp) {
+export function checkFlpSandboxAvailability(fs, rootPath, webappPath, FEVersion, isSAPApp) {
     const testFlpSandboxHtml = 'test/flpSandbox.html';
     const flpSandboxPath = join(rootPath, webappPath, testFlpSandboxHtml);
-    return ((await fileExists(flpSandboxPath)) ||
+    return (fileExists(fs, flpSandboxPath) ||
         FEVersion === FioriElementsVersion.v2 ||
         FEVersion === FioriElementsVersion.v4 ||
         isSAPApp);
@@ -63,13 +64,14 @@ export function generateAppMockIntent(semanticObject, flpSandboxAvailable, flpSa
  * Generate all FLP-related intents and availability flags
  * Consolidates FLP sandbox checking and intent generation
  *
+ * @param fs
  * @param projectInfo
  * @param semanticObject
  */
-export async function prepareFlpConfiguration(projectInfo, semanticObject) {
+export function prepareFlpConfiguration(fs, projectInfo, semanticObject) {
     const { rootPath, webappPath, FEVersion, isSAPApp = false, flpSandboxFlpIntent, flpSandboxMockFlpIntent } = projectInfo;
     // Check FLP sandbox availability
-    const flpSandboxAvailable = await checkFlpSandboxAvailability(rootPath, webappPath, FEVersion, isSAPApp);
+    const flpSandboxAvailable = checkFlpSandboxAvailability(fs, rootPath, webappPath, FEVersion, isSAPApp);
     // Generate app intents
     const appIntent = generateAppIntent(projectInfo, semanticObject, flpSandboxAvailable, flpSandboxFlpIntent);
     const appMockIntent = generateAppMockIntent(semanticObject, flpSandboxAvailable, flpSandboxMockFlpIntent, flpSandboxFlpIntent);

package/dist/config/flp/sandbox.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Result of FLP sandbox processing
  */
@@ -15,11 +16,12 @@ export interface FlpSandboxProcessingResult {
  * Process FLP sandbox HTML files to extract libraries, intents, and root intent flags
  * Handles both flpSandbox.html and flpSandboxMockServer.html in parallel
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @param webappPath - Webapp path within the project
  * @param getFlpIntentFromHtml - Function to extract intent from HTML file
  * @param existingFlpIntent - Existing FLP intent (optional)
  * @returns FLP sandbox processing result
  */
-export declare function processFlpSandboxFiles(projectRoot: string, webappPath: string, getFlpIntentFromHtml: (path: string) => Promise<string | undefined>, existingFlpIntent?: string): Promise<FlpSandboxProcessingResult>;
+export declare function processFlpSandboxFiles(fs: Editor, projectRoot: string, webappPath: string, getFlpIntentFromHtml: (path: string) => string | undefined, existingFlpIntent?: string): Promise<FlpSandboxProcessingResult>;
 //# sourceMappingURL=sandbox.d.ts.map

package/dist/config/flp/sandbox.js

@@ -7,19 +7,20 @@ import { fileExists, readFile } from '../../utils/index.js';
  * Process FLP sandbox HTML files to extract libraries, intents, and root intent flags
  * Handles both flpSandbox.html and flpSandboxMockServer.html in parallel
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @param webappPath - Webapp path within the project
  * @param getFlpIntentFromHtml - Function to extract intent from HTML file
  * @param existingFlpIntent - Existing FLP intent (optional)
  * @returns FLP sandbox processing result
  */
-export async function processFlpSandboxFiles(projectRoot, webappPath, getFlpIntentFromHtml, existingFlpIntent) {
+export async function processFlpSandboxFiles(fs, projectRoot, webappPath, getFlpIntentFromHtml, existingFlpIntent) {
     const flpSandboxPath = join(projectRoot, webappPath, 'test', 'flpSandbox.html');
     const flpSandboxMockPath = join(projectRoot, webappPath, 'test', 'flpSandboxMockServer.html');
     // Process both files in parallel for better performance
     const [sandboxResult, mockResult] = await Promise.all([
-        processSandboxFile(flpSandboxPath, getFlpIntentFromHtml, existingFlpIntent),
-        processMockSandboxFile(flpSandboxMockPath, getFlpIntentFromHtml)
+        processSandboxFile(fs, flpSandboxPath, getFlpIntentFromHtml, existingFlpIntent),
+        processMockSandboxFile(fs, flpSandboxMockPath, getFlpIntentFromHtml)
     ]);
     return {
         flpSandboxLibs: sandboxResult.libs,
@@ -35,17 +36,18 @@ export async function processFlpSandboxFiles(projectRoot, webappPath, getFlpInte
 /**
  * Process main FLP sandbox file
  *
+ * @param fs - mem-fs editor
  * @param filePath - Path to flpSandbox.html
  * @param getFlpIntentFromHtml - Function to extract intent from HTML
  * @param existingFlpIntent - Existing FLP intent
  * @returns Sandbox processing result
  */
-async function processSandboxFile(filePath, getFlpIntentFromHtml, existingFlpIntent) {
+async function processSandboxFile(fs, filePath, getFlpIntentFromHtml, existingFlpIntent) {
     try {
-        if (!(await fileExists(filePath))) {
+        if (!fileExists(fs, filePath)) {
             return { libs: '', hasRootIntent: false };
         }
-        const content = readFile(filePath);
+        const content = readFile(fs, filePath);
         const libs = extractDataSapUiLibs(content);
         const hasRootIntent = content.includes('rootIntent');
         const intent = await getFlpIntentFromHtml(filePath);
@@ -63,17 +65,21 @@ async function processSandboxFile(filePath, getFlpIntentFromHtml, existingFlpInt
 /**
  * Process mock FLP sandbox file
  *
+ * @param fs - mem-fs editor
  * @param filePath - Path to flpSandboxMockServer.html
  * @param getFlpIntentFromHtml - Function to extract intent from HTML
  * @returns Mock sandbox processing result
  */
-async function processMockSandboxFile(filePath, getFlpIntentFromHtml) {
+async function processMockSandboxFile(fs, filePath, getFlpIntentFromHtml) {
     try {
-        const [intent, exists] = await Promise.all([getFlpIntentFromHtml(filePath), fileExists(filePath)]);
+        const intent = await getFlpIntentFromHtml(filePath);
+        const exists = fileExists(fs, filePath);
         if (!exists) {
-            return { hasRootIntent: false };
+            // flpSandboxMockServer.html is generated by the migration for any project that has a
+            // mock sandbox, so the launch config must target it even when it is not yet on disk.
+            return { hasRootIntent: false, targetFile: 'test/flpSandboxMockServer.html' };
         }
-        const content = readFile(filePath);
+        const content = readFile(fs, filePath);
         const hasRootIntent = content.includes('rootIntent');
         return {
             intent,
@@ -83,8 +89,7 @@ async function processMockSandboxFile(filePath, getFlpIntentFromHtml) {
     }
     catch {
         // Expected: flpSandboxMockServer.html may not exist or may be unreadable in legacy projects.
-        // Safe to return empty defaults - mock server configuration is optional.
-        return { hasRootIntent: false };
+        return { hasRootIntent: false, targetFile: 'test/flpSandboxMockServer.html' };
     }
 }
 /**

package/dist/config/launch-config.d.ts

@@ -1,16 +1,17 @@
 /**
  * Helper functions for generating VS Code launch configuration during migration
  */
-import type { ImportProjectInfo, Message } from '../types.js';
+import type { Editor } from 'mem-fs-editor';
+import type { ImportProjectInfo } from '../types.js';
 /**
  * Generate and write VS Code launch configuration for the migrated project
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param vscode - VS Code context
  * @param appIntent - FLP app intent string (e.g., "#SemanticObject-Action")
  * @param appMockIntent - Mock intent string for FLP sandbox
  * @param flpSandboxAvailable - Whether FLP sandbox is available
- * @param messages - Array to collect warning/error messages
  */
-export declare function generateLaunchConfiguration(projectInfo: ImportProjectInfo, vscode: any, appIntent: string | undefined, appMockIntent: string | undefined, flpSandboxAvailable: boolean, messages: Message[]): Promise<void>;
+export declare function generateLaunchConfiguration(fs: Editor, projectInfo: ImportProjectInfo, vscode: any, appIntent: string | undefined, appMockIntent: string | undefined, flpSandboxAvailable: boolean): Promise<void>;
 //# sourceMappingURL=launch-config.d.ts.map

package/dist/config/launch-config.js

@@ -9,14 +9,14 @@ import { ODataVersion } from '../types.js';
 /**
  * Generate and write VS Code launch configuration for the migrated project
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param vscode - VS Code context
  * @param appIntent - FLP app intent string (e.g., "#SemanticObject-Action")
  * @param appMockIntent - Mock intent string for FLP sandbox
  * @param flpSandboxAvailable - Whether FLP sandbox is available
- * @param messages - Array to collect warning/error messages
  */
-export async function generateLaunchConfiguration(projectInfo, vscode, appIntent, appMockIntent, flpSandboxAvailable, messages) {
+export async function generateLaunchConfiguration(fs, projectInfo, vscode, appIntent, appMockIntent, flpSandboxAvailable) {
     const projectName = projectInfo.rootPath.split(pathSep).pop();
     const targetFolder = join(projectInfo.rootPath, '..');
     const projectPath = join(targetFolder, projectName);
@@ -42,19 +42,8 @@ export async function generateLaunchConfiguration(projectInfo, vscode, appIntent
         projectRoot: projectPath,
         debugOptions
     };
-    // Generate launch config using @sap-ux/launch-config
-    const fsEditor = await createLaunchConfig(projectPath, fioriOptions);
-    // Commit the changes to filesystem
-    await new Promise((resolve) => {
-        fsEditor.commit((err) => {
-            if (err) {
-                messages.push({
-                    type: 'ERROR',
-                    description: `Error committing changes while configuring launch json file: ${err}`
-                });
-            }
-            resolve();
-        });
-    });
+    // Generate launch config using @sap-ux/launch-config, writing into the shared editor.
+    // The migration commits the editor once at the end, so no separate commit here.
+    await createLaunchConfig(projectPath, fioriOptions, fs);
 }
 //# sourceMappingURL=launch-config.js.map

package/dist/config/manifest-update.d.ts

@@ -1,11 +1,13 @@
 /**
  * Helper functions for updating manifest.json during migration
  */
+import type { Editor } from 'mem-fs-editor';
 import type { SapAppSourceTemplate } from '../project-spec-types.js';
 import type { TemplateData, Message } from '../types.js';
 /**
  * Update manifest.json file with migration-specific changes
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param webappPath - Webapp path relative to root
  * @param templateData - Template data containing project configuration
@@ -14,5 +16,23 @@ import type { TemplateData, Message } from '../types.js';
  * @param sourceTemplateTest - Test-only source template values
  * @param strict - Enable strict validation mode (WARNING becomes ERROR)
  */
-export declare function updateManifestForMigration(rootPath: string, webappPath: string, templateData: TemplateData, floorplan: string, messages: Message[], sourceTemplateTest?: SapAppSourceTemplate, strict?: boolean): Promise<void>;
+/**
+ * Options for updateManifestForMigration
+ */
+export interface UpdateManifestForMigrationOptions {
+    fs: Editor;
+    rootPath: string;
+    webappPath: string;
+    templateData: TemplateData;
+    floorplan: string;
+    messages: Message[];
+    sourceTemplateTest?: SapAppSourceTemplate;
+    strict?: boolean;
+}
+/**
+ * Update manifest.json for migration.
+ *
+ * @param options - Manifest update options
+ */
+export declare function updateManifestForMigration(options: UpdateManifestForMigrationOptions): Promise<void>;
 //# sourceMappingURL=manifest-update.d.ts.map

package/dist/config/manifest-update.js

@@ -10,24 +10,19 @@ import { i18nText } from '../i18n.js';
 import { processDataSource } from './manifest-update-helpers.js';
 import { getMessageType } from '../utils/validation-severity.js';
 /**
- * Update manifest.json file with migration-specific changes
+ * Update manifest.json for migration.
  *
- * @param rootPath - Root path of the project
- * @param webappPath - Webapp path relative to root
- * @param templateData - Template data containing project configuration
- * @param floorplan - Floor plan type
- * @param messages - Array to collect warning messages
- * @param sourceTemplateTest - Test-only source template values
- * @param strict - Enable strict validation mode (WARNING becomes ERROR)
+ * @param options - Manifest update options
  */
-export async function updateManifestForMigration(rootPath, webappPath, templateData, floorplan, messages, sourceTemplateTest, strict = false) {
+export async function updateManifestForMigration(options) {
+    const { fs, rootPath, webappPath, templateData, floorplan, messages, sourceTemplateTest, strict = false } = options;
     const manifestPath = join(webappPath, TemplateFileName.ManifestJson);
-    if (!(await fileExists(join(rootPath, manifestPath)))) {
+    if (!fileExists(fs, join(rootPath, manifestPath))) {
         return;
     }
     let manifestJson;
     try {
-        manifestJson = await readJSON(join(rootPath, manifestPath));
+        manifestJson = await readJSON(fs, join(rootPath, manifestPath));
     }
     catch (e) {
         throw new MigrationError(e, TemplateFileName.ManifestJson);
@@ -55,7 +50,7 @@ export async function updateManifestForMigration(rootPath, webappPath, templateD
         });
     }
     if (saveFile === true) {
-        updateJSON(join(rootPath, manifestPath), manifestJson);
+        updateJSON(fs, join(rootPath, manifestPath), manifestJson);
     }
 }
 /**

package/dist/config/package-json.d.ts

@@ -1,12 +1,14 @@
 /**
  * Helper functions for generating package.json configuration during migration
  */
+import type { Editor } from 'mem-fs-editor';
 import type { PackageJsonMigrate, PackageJsonContext } from '../types.js';
 /**
  * Generate package.json configuration for migration
  *
+ * @param fs - mem-fs editor
  * @param context - Configuration context containing all necessary parameters
  * @returns Package.json configuration object
  */
-export declare function generatePackageJsonConfig(context: PackageJsonContext): Promise<PackageJsonMigrate>;
+export declare function generatePackageJsonConfig(fs: Editor, context: PackageJsonContext): PackageJsonMigrate;
 //# sourceMappingURL=package-json.d.ts.map

package/dist/config/package-json.js

@@ -22,10 +22,11 @@ const TEST_FILES = [
 /**
  * Generate package.json configuration for migration
  *
+ * @param fs - mem-fs editor
  * @param context - Configuration context containing all necessary parameters
  * @returns Package.json configuration object
  */
-export async function generatePackageJsonConfig(context) {
+export function generatePackageJsonConfig(fs, context) {
     const { projectInfo, moduleName, moduleDescription, sapClient, dependencies, flpConfig, flags } = context;
     const { devDependencies, ui5Dependencies, v4MockServerDep } = dependencies;
     const { semanticObject, appIntent, appMockIntent, testFlpSandboxHtml, urlParam } = flpConfig;
@@ -49,21 +50,26 @@ export async function generatePackageJsonConfig(context) {
             command: `fiori run --open 'editor.html'`
         });
     }
-    // Check for test files and add corresponding scripts in parallel
-    const testScriptResults = await Promise.all(TEST_FILES.map(async (testFile) => {
+    // Check for test files and add corresponding scripts
+    const testScriptResults = TEST_FILES.map((testFile) => {
         const scriptName = `${testFile.type}-tests`;
-        const exists = await fileExists(join(projectInfo.rootPath, projectInfo.webappPath, testFile.path));
-        const alreadyExists = runTasks.some((runTask) => runTask.name === scriptName);
-        if (exists && !alreadyExists) {
+        const exists = fileExists(fs, join(projectInfo.rootPath, projectInfo.webappPath, testFile.path));
+        if (exists) {
             return {
                 name: scriptName,
                 command: String.raw `fiori run --open \"${testFile.path}\"`
             };
         }
         return null;
-    }));
-    // Add non-null test scripts to runTasks
-    runTasks.push(...testScriptResults.filter((script) => script !== null));
+    });
+    // Add non-null test scripts to runTasks, deduplicating by script name (first match wins)
+    const seenScriptNames = new Set(runTasks.map((t) => t.name));
+    for (const script of testScriptResults) {
+        if (script !== null && !seenScriptNames.has(script.name)) {
+            runTasks.push(script);
+            seenScriptNames.add(script.name);
+        }
+    }
     // Clone UI5 dependencies and add V4 mock server if needed
     const ui5DepsCloned = [...ui5Dependencies];
     if (odataVersion === ODataVersion.v4) {

package/dist/config/ui5-yaml.d.ts

@@ -4,6 +4,7 @@
  *
  * Uses modern @sap-ux/ui5-config API via adapter layer instead of EJS templates.
  */
+import type { Editor } from 'mem-fs-editor';
 import type { TemplateData, NeoappDestination, Message } from '../types.js';
 /**
  * Configuration for generating UI5 YAML files
@@ -60,26 +61,30 @@ export interface UI5YamlAllFilesConfig {
 /**
  * Generate and write ui5.yaml file using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export declare function generateAndWriteUI5Yaml(config: UI5YamlGenerationConfig): Promise<void>;
+export declare function generateAndWriteUI5Yaml(fs: Editor, config: UI5YamlGenerationConfig): Promise<void>;
 /**
  * Generate and write ui5-local.yaml file using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export declare function generateAndWriteUI5LocalYaml(config: UI5LocalYamlGenerationConfig): Promise<void>;
+export declare function generateAndWriteUI5LocalYaml(fs: Editor, config: UI5LocalYamlGenerationConfig): Promise<void>;
 /**
  * Generate and write ui5-mock.yaml file if required using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export declare function generateAndWriteUI5MockYaml(config: UI5MockYamlGenerationConfig): Promise<void>;
+export declare function generateAndWriteUI5MockYaml(fs: Editor, config: UI5MockYamlGenerationConfig): Promise<void>;
 /**
  * Generate all UI5 YAML files (ui5.yaml, ui5-local.yaml, ui5-mock.yaml)
  * using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export declare function generateAllUI5YamlFiles(config: UI5YamlAllFilesConfig): Promise<void>;
+export declare function generateAllUI5YamlFiles(fs: Editor, config: UI5YamlAllFilesConfig): Promise<void>;
 //# sourceMappingURL=ui5-yaml.d.ts.map

package/dist/config/ui5-yaml.js

@@ -12,9 +12,10 @@ import { generateUI5YamlContent, generateUI5LocalYamlContent, generateUI5MockYam
 /**
  * Generate and write ui5.yaml file using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export async function generateAndWriteUI5Yaml(config) {
+export async function generateAndWriteUI5Yaml(fs, config) {
     const { templateData, neoappDestinations, messages, destination, firstNeoAppDestination, webappPath, setUI5version, rootPath, strict = false } = config;
     const ui5YamlContent = await generateUI5YamlContent({
         templateData,
@@ -26,14 +27,15 @@ export async function generateAndWriteUI5Yaml(config) {
         setUI5Version: setUI5version,
         strict
     });
-    updateFile(join(rootPath, TemplateFileName.UI5Yaml), ui5YamlContent);
+    updateFile(fs, join(rootPath, TemplateFileName.UI5Yaml), ui5YamlContent);
 }
 /**
  * Generate and write ui5-local.yaml file using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export async function generateAndWriteUI5LocalYaml(config) {
+export async function generateAndWriteUI5LocalYaml(fs, config) {
     const { templateData, neoappDestinations, messages, destination, firstNeoAppDestination, webappPath, rootPath, strict = false } = config;
     // Only generate for regular projects, not library or extension projects
     if (templateData.project.type !== MigrationTypes.project) {
@@ -48,14 +50,15 @@ export async function generateAndWriteUI5LocalYaml(config) {
         webappPath,
         strict
     });
-    updateFile(join(rootPath, TemplateFileName.UI5LocalYaml), ui5LocalYamlContent);
+    updateFile(fs, join(rootPath, TemplateFileName.UI5LocalYaml), ui5LocalYamlContent);
 }
 /**
  * Generate and write ui5-mock.yaml file if required using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export async function generateAndWriteUI5MockYaml(config) {
+export async function generateAndWriteUI5MockYaml(fs, config) {
     const { templateData, webappPath, setUI5version, rootPath, hasDataSource } = config;
     if (!hasDataSource) {
         return;
@@ -65,19 +68,20 @@ export async function generateAndWriteUI5MockYaml(config) {
         return;
     }
     const ui5MockYamlContent = await generateUI5MockYamlContent(templateData, webappPath, setUI5version);
-    updateFile(join(rootPath, TemplateFileName.UI5MockYaml), ui5MockYamlContent);
+    updateFile(fs, join(rootPath, TemplateFileName.UI5MockYaml), ui5MockYamlContent);
 }
 /**
  * Generate all UI5 YAML files (ui5.yaml, ui5-local.yaml, ui5-mock.yaml)
  * using modern @sap-ux/ui5-config API
  *
+ * @param fs - mem-fs editor
  * @param config - Configuration object containing all required parameters
  */
-export async function generateAllUI5YamlFiles(config) {
+export async function generateAllUI5YamlFiles(fs, config) {
     const { templateData, neoappDestinations, messages, destination, firstNeoAppDestination, webappPath, setUI5version, rootPath, hasDataSource, strict = false } = config;
     // Generate all YAML files in parallel for better performance
     await Promise.all([
-        generateAndWriteUI5Yaml({
+        generateAndWriteUI5Yaml(fs, {
             templateData,
             neoappDestinations,
             messages,
@@ -88,7 +92,7 @@ export async function generateAllUI5YamlFiles(config) {
             rootPath,
             strict
         }),
-        generateAndWriteUI5LocalYaml({
+        generateAndWriteUI5LocalYaml(fs, {
             templateData,
             neoappDestinations,
             messages,
@@ -98,7 +102,7 @@ export async function generateAllUI5YamlFiles(config) {
             rootPath,
             strict
         }),
-        generateAndWriteUI5MockYaml({
+        generateAndWriteUI5MockYaml(fs, {
             templateData,
             webappPath,
             setUI5version,

package/dist/data/sap-libraries.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Result of SAP libraries extraction
  */
@@ -9,10 +10,11 @@ export interface SapLibrariesExtractionResult {
  * Extract and filter SAP libraries from manifest into SAPUI5 libs and reuse libs
  * Handles filtering by SAP namespaces and checking for legacy sap.ca.scfld.md in Component.js
  *
+ * @param fs - mem-fs editor
  * @param manifestLibsTmp - Raw libraries object from manifest['sap.ui5'].dependencies.libs
  * @param projectRoot - Root path of the project
  * @param webappPath - Webapp path within the project
  * @returns SAP libraries extraction result
  */
-export declare function extractSapLibraries(manifestLibsTmp: Record<string, any>, projectRoot: string, webappPath: string): Promise<SapLibrariesExtractionResult>;
+export declare function extractSapLibraries(fs: Editor, manifestLibsTmp: Record<string, any>, projectRoot: string, webappPath: string): SapLibrariesExtractionResult;
 //# sourceMappingURL=sap-libraries.d.ts.map

package/dist/data/sap-libraries.js

@@ -8,12 +8,13 @@ import { sapUI5LibsNS } from '../utils/constants.js';
  * Extract and filter SAP libraries from manifest into SAPUI5 libs and reuse libs
  * Handles filtering by SAP namespaces and checking for legacy sap.ca.scfld.md in Component.js
  *
+ * @param fs - mem-fs editor
  * @param manifestLibsTmp - Raw libraries object from manifest['sap.ui5'].dependencies.libs
  * @param projectRoot - Root path of the project
  * @param webappPath - Webapp path within the project
  * @returns SAP libraries extraction result
  */
-export async function extractSapLibraries(manifestLibsTmp, projectRoot, webappPath) {
+export function extractSapLibraries(fs, manifestLibsTmp, projectRoot, webappPath) {
     const manifestLibs = {};
     const reuseManifestLibs = {};
     // Filter libraries by SAP namespaces
@@ -31,9 +32,9 @@ export async function extractSapLibraries(manifestLibsTmp, projectRoot, webappPa
     // Check for sap.ca.scfld.md in component.js in older projects
     try {
         const componentJSPath = join(projectRoot, webappPath, 'Component.js');
-        if (await fileExists(componentJSPath)) {
+        if (fileExists(fs, componentJSPath)) {
             // sap.ca.scfld.md
-            const componentJsContent = readFile(componentJSPath);
+            const componentJsContent = readFile(fs, componentJSPath);
             if (componentJsContent.indexOf('sap.ca.scfld.md') > 0) {
                 manifestLibs['sap.ca.scfld.md'] = {};
                 manifestLibs['sap.collaboration'] = {};