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

package/dist/project/adaptation-project.js

@@ -34,6 +34,7 @@ export async function processAdaptationProject(config) {
                 ui5Version,
                 isFioriToolsProject,
                 destination,
+                targetMockHtmlFile: 'test/flpSandboxMockServer.html',
                 ...neoAppData
             };
             if (neoAppData?.destination) {

package/dist/project/project-data.js

@@ -60,7 +60,7 @@ export function createProjectData(config) {
         ui5Theme: ui5Theme,
         ui5Version: projectUI5Version,
         minSupportedUI5Version: odataVersion === ODataVersion.v4 ? minUi5VersionV4Template : defaultMinUi5Version,
-        localUI5Version: projectUI5Version.length > 0 ? projectUI5Version : localUI5Version,
+        localUI5Version: localUI5Version,
         manifestUI5Version,
         neoAppUI5Version,
         sapux: !isSAPApp,

package/dist/project/project-detection.d.ts

@@ -1,9 +1,11 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Validates that the project is suitable for migration.
  * Checks if project is within a CAP project structure and rejects if so.
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root directory of the project to validate
  * @throws {MigrationError} If project is a Fiori app within a CAP project
  */
-export declare function validateProjectForMigration(projectRoot: string): Promise<void>;
+export declare function validateProjectForMigration(fs: Editor, projectRoot: string): Promise<void>;
 //# sourceMappingURL=project-detection.d.ts.map

package/dist/project/project-detection.js

@@ -1,16 +1,22 @@
-import { findProjectRoot, getProjectType, fileExists } from '../utils/index.js';
+import { access } from 'node:fs/promises';
+import { findProjectRoot, getProjectType } from '../utils/index.js';
 import { MigrationError } from '../utils/common.js';
 import { i18nText } from '../i18n.js';
 /**
  * Validates that the project is suitable for migration.
  * Checks if project is within a CAP project structure and rejects if so.
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root directory of the project to validate
  * @throws {MigrationError} If project is a Fiori app within a CAP project
  */
-export async function validateProjectForMigration(projectRoot) {
-    // Quick existence check to avoid hanging on non-existent paths
-    if (!(await fileExists(projectRoot))) {
+export async function validateProjectForMigration(fs, projectRoot) {
+    // Quick existence check to avoid hanging on non-existent paths.
+    // This is a directory check on the real filesystem (mem-fs exists() only reports files).
+    try {
+        await access(projectRoot);
+    }
+    catch {
         // Path doesn't exist - skip validation (will fail later with appropriate error)
         return;
     }

package/dist/project/project-extension.d.ts

@@ -24,7 +24,7 @@ export interface ProcessProjectExtensionConfig {
         url?: string;
     };
     getClientFromDestinationName: (destination: string) => string;
-    getFlpIntentFromHtml: (path: string) => Promise<string | undefined>;
+    getFlpIntentFromHtml: (path: string) => string | undefined;
     getManifestJson: (projectRoot: string, webappPath: string) => Promise<Manifest>;
 }
 /**

package/dist/project/project-extension.js

@@ -85,7 +85,9 @@ export async function processProjectExtension(config) {
         neoappDestinations,
         extensionProjectSettings,
         ui5Version,
-        appVersion
+        appVersion,
+        targetMockHtmlFile: 'test/flpSandboxMockServer.html',
+        ...(projectInfo.flpSandboxFlpIntent ? { flpSandboxFlpIntent: projectInfo.flpSandboxFlpIntent } : {})
     };
     if (manifest) {
         result.manifestUI5Version = getMinUI5VersionAsArray(manifest, true)[0] || '';

package/dist/project/project-info.d.ts

@@ -1,12 +1,14 @@
 import type { ImportProjectInfo, Message } from '../types.js';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Loads project information either from provided data or by fetching from project root.
  *
  * @param projectRoot - Root directory of the project
  * @param importProjectInfo - Optional project info (complete or partial overrides)
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns Project info and any messages
  */
-export declare function loadOrFetchProjectInfo(projectRoot: string, importProjectInfo?: Partial<ImportProjectInfo>): Promise<{
+export declare function loadOrFetchProjectInfo(projectRoot: string, importProjectInfo?: Partial<ImportProjectInfo>, fsEditor?: Editor): Promise<{
     projectInfo: ImportProjectInfo;
     messages: Message[];
 }>;

package/dist/project/project-info.js

@@ -1,12 +1,15 @@
 import { ProjectAccess } from '../utils/Project.js';
+import { createMemFsEditor } from '../utils/fs-adapter.js';
 /**
  * Loads project information either from provided data or by fetching from project root.
  *
  * @param projectRoot - Root directory of the project
  * @param importProjectInfo - Optional project info (complete or partial overrides)
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns Project info and any messages
  */
-export async function loadOrFetchProjectInfo(projectRoot, importProjectInfo) {
+export async function loadOrFetchProjectInfo(projectRoot, importProjectInfo, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
     let messages = [];
     let projectInfo;
     // Check if importProjectInfo is complete (has critical fields)
@@ -17,14 +20,14 @@ export async function loadOrFetchProjectInfo(projectRoot, importProjectInfo) {
     }
     else if (importProjectInfo) {
         // Fetch project info and merge with partial overrides (CLI usage)
-        const { messages: projectInfoMsgs, projectInfo: accessProjectInfo } = await ProjectAccess.getProjectInfo(projectRoot);
+        const { messages: projectInfoMsgs, projectInfo: accessProjectInfo } = await ProjectAccess.getProjectInfo(projectRoot, undefined, undefined, undefined, fs);
         messages = messages.concat(projectInfoMsgs);
         // Merge CLI overrides with fetched project info
         projectInfo = { ...accessProjectInfo, ...importProjectInfo };
     }
     else {
         // No project info provided, fetch it
-        const { messages: projectInfoMsgs, projectInfo: accessProjectInfo } = await ProjectAccess.getProjectInfo(projectRoot);
+        const { messages: projectInfoMsgs, projectInfo: accessProjectInfo } = await ProjectAccess.getProjectInfo(projectRoot, undefined, undefined, undefined, fs);
         messages = messages.concat(projectInfoMsgs);
         projectInfo = accessProjectInfo;
     }

package/dist/project/regular-project.js

@@ -16,7 +16,7 @@ import { generateSapLibsStr, checkManifestUI5Version } from '../utils/common.js'
  * @returns Project info for regular project and any messages
  */
 export async function processRegularProject(context) {
-    const { projectRoot, manifest, defaultProjectInfo, services } = context;
+    const { fs, projectRoot, manifest, defaultProjectInfo, services } = context;
     let projectInfo = context.projectInfo; // Use let since this is reassigned
     const { projectData, manifestAnalysis, backendConfig } = services;
     // Extract service methods
@@ -65,7 +65,7 @@ export async function processRegularProject(context) {
     }
     // Step3. Get the template details
     try {
-        const templateDetails = await extractTemplateDetails(manifest, projectRoot, mainService ?? '', appVersion, getVersionFromManifest, getFloorPlan);
+        const templateDetails = extractTemplateDetails(fs, manifest, projectRoot, mainService ?? '', appVersion, getVersionFromManifest, getFloorPlan);
         feVersion = templateDetails.feVersion;
         isSAPApp = templateDetails.isSAPApp;
         floorPlan = templateDetails.floorPlan;
@@ -75,7 +75,16 @@ export async function processRegularProject(context) {
         projectName = sapAppId;
         namespace = namespace || '';
         // Extract backend configuration and app title from i18n
-        const backendConfig = await extractBackendAndI18nConfig(projectRoot, projectInfo.webappPath, getFirstBackend, destination, scp, hostname, sapClient);
+        const backendConfig = await extractBackendAndI18nConfig({
+            fs,
+            projectRoot,
+            webappPath: projectInfo.webappPath,
+            getFirstBackend,
+            existingDestination: destination,
+            existingScp: scp,
+            existingHostname: hostname,
+            existingSapClient: sapClient
+        });
         // Note: destination will be set from neoAppResult later (line 192)
         scp = backendConfig.scp;
         hostname = backendConfig.hostname;
@@ -86,18 +95,16 @@ export async function processRegularProject(context) {
         // @ts-ignore
         const manifestLibsTmp = manifest['sap.ui5']?.dependencies?.libs || {};
         // Extract and filter SAP libraries from manifest
-        const { manifestLibs, reuseManifestLibs } = await extractSapLibraries(manifestLibsTmp, projectRoot, projectInfo.webappPath);
+        const { manifestLibs, reuseManifestLibs } = extractSapLibraries(fs, manifestLibsTmp, projectRoot, projectInfo.webappPath);
         // Process FLP sandbox files to extract libs, intents, and root intent flags
-        const flpResult = await processFlpSandboxFiles(projectRoot, projectInfo.webappPath, getFlpIntentFromHtml, flpSandboxFlpIntent);
+        const flpResult = await processFlpSandboxFiles(fs, projectRoot, projectInfo.webappPath, getFlpIntentFromHtml, flpSandboxFlpIntent);
         // Assign to existing variables
         flpSandboxLibs = flpResult.flpSandboxLibs;
         flpSandboxFlpIntent = flpResult.flpSandboxFlpIntent;
         flpSandboxMockFlpIntent = flpResult.flpSandboxMockFlpIntent;
         hasRootIntent.flpSandboxRootIntent = flpResult.hasRootIntent.flpSandboxRootIntent;
         hasRootIntent.flpSandboxMockRootIntent = flpResult.hasRootIntent.flpSandboxMockRootIntent;
-        if (flpResult.targetMockHtmlFile) {
-            projectInfo.targetMockHtmlFile = flpResult.targetMockHtmlFile;
-        }
+        const targetMockHtmlFile = flpResult.targetMockHtmlFile;
         // Process neo-app configuration and determine OData version
         const neoAppResult = await processNeoAppAndODataVersion(projectRoot, projectInfo.destination, // Use projectInfo.destination, not the local 'destination' variable
         sapClient, mainServiceDatasource, feVersion, getDestinationFromNeoApp, getClientFromDestinationName);
@@ -154,7 +161,8 @@ export async function processRegularProject(context) {
             neoappDestinations,
             firstNeoAppDestination,
             hasRootIntent,
-            reuseLibs: Object.keys(reuseManifestLibs || {}).join(',')
+            reuseLibs: Object.keys(reuseManifestLibs || {}).join(','),
+            ...(targetMockHtmlFile ? { targetMockHtmlFile } : {})
         };
     }
     catch (error) {

package/dist/template/application.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { FioriElementsVersion } from '../project-spec-types.js';
 import type { ImportProjectInfo, TemplateData } from '../types.js';
 import type { MigrationTypes } from '../utils/constants.js';
@@ -5,6 +6,7 @@ import type { MigrationTypes } from '../utils/constants.js';
  * Configuration for applying application templates
  */
 export interface ApplyApplicationTemplatesConfig {
+    fs: Editor;
     projectInfo: ImportProjectInfo;
     templateData: TemplateData;
     rootPath: string;

package/dist/template/application.js

@@ -10,10 +10,10 @@ import { applyTemplates } from './template-helpers.js';
  * @param config - Configuration object containing all required parameters
  */
 export async function applyApplicationTemplates(config) {
-    const { projectInfo, templateData, rootPath, appIntent, appMockIntent, hasDataSource, isSAPApp, ui5Version, MigrationTypesEnum: migrationTypesEnum, FioriElementsVersionEnum: fioriElementsVersionEnum } = config;
+    const { fs, projectInfo, templateData, rootPath, appIntent, appMockIntent, hasDataSource, isSAPApp, ui5Version, MigrationTypesEnum: migrationTypesEnum, FioriElementsVersionEnum: fioriElementsVersionEnum } = config;
     // Step4b. Apply specific application templates
     if (isSAPApp || projectInfo.FEVersion === fioriElementsVersionEnum.v2) {
-        await applyV2OrSapAppTemplates(projectInfo, templateData, rootPath, {
+        await applyV2OrSapAppTemplates(fs, projectInfo, templateData, rootPath, {
             appIntent,
             appMockIntent,
             hasDataSource,
@@ -23,18 +23,19 @@ export async function applyApplicationTemplates(config) {
         });
     }
     else if (projectInfo.FEVersion === fioriElementsVersionEnum.v4) {
-        await applyV4Templates(projectInfo, templateData, rootPath, appIntent, ui5Version);
+        await applyV4Templates(fs, projectInfo, templateData, rootPath, appIntent, ui5Version);
     }
 }
 /**
  * Applies templates for V2 Fiori Elements or SAP apps
  *
+ * @param fs
  * @param projectInfo
  * @param templateData
  * @param rootPath
  * @param config
  */
-async function applyV2OrSapAppTemplates(projectInfo, templateData, rootPath, config) {
+async function applyV2OrSapAppTemplates(fs, projectInfo, templateData, rootPath, config) {
     const { appIntent, appMockIntent, hasDataSource, isSAPApp, ui5Version, migrationTypesEnum } = config;
     const appTemplates = isSAPApp ? getSapTemplatesMap() : getFeTemplatesMap(projectInfo.webappPath);
     // Only update component.js in case app has namespace and is v2
@@ -57,7 +58,7 @@ async function applyV2OrSapAppTemplates(projectInfo, templateData, rootPath, con
     templateDataFlpMock.project.flpAppId = appMockIntent?.replace('#', '');
     // Apply FLP sandbox templates (unless extension project)
     if (projectInfo.type !== migrationTypesEnum.projectExtension) {
-        await applyTemplates({ ...getFLPSandboxTemplatesMap(projectInfo.webappPath), ...appTemplates }, templateDataFlp, rootPath, isSAPApp ? TemplateFileName.SAPApp : TemplateFileName.AppSettings, ui5Version);
+        await applyTemplates(fs, { ...getFLPSandboxTemplatesMap(projectInfo.webappPath), ...appTemplates }, templateDataFlp, rootPath, isSAPApp ? TemplateFileName.SAPApp : TemplateFileName.AppSettings, ui5Version);
     }
     // Apply mock server templates if data source exists
     let mockServerFiles;
@@ -66,7 +67,7 @@ async function applyV2OrSapAppTemplates(projectInfo, templateData, rootPath, con
         const mockServerFileName = templateData.mockServerJSFileName || 'mockserver';
         const mockServerJsPath = join(projectInfo.rootPath, projectInfo.webappPath, DirName.LocalService, mockServerFileName.endsWith('.js') ? mockServerFileName : `${mockServerFileName}.js`);
         // Create mockserver.js if it doesn't exist
-        if (!(await fileExists(mockServerJsPath))) {
+        if (!fileExists(fs, mockServerJsPath)) {
             mockServerFiles[TemplateFileName.MockServer] = {
                 path: join(DirName.Webapp, DirName.LocalService),
                 targetPath: join(projectInfo.webappPath, DirName.LocalService),
@@ -74,22 +75,23 @@ async function applyV2OrSapAppTemplates(projectInfo, templateData, rootPath, con
             };
         }
     }
-    await applyTemplates({ ...mockServerFiles, ...appTemplates }, templateDataFlpMock, rootPath, isSAPApp ? TemplateFileName.SAPApp : TemplateFileName.AppSettings, ui5Version);
+    await applyTemplates(fs, { ...mockServerFiles, ...appTemplates }, templateDataFlpMock, rootPath, isSAPApp ? TemplateFileName.SAPApp : TemplateFileName.AppSettings, ui5Version);
 }
 /**
  * Applies templates for V4 Fiori Elements apps
  *
+ * @param fs
  * @param projectInfo
  * @param templateData
  * @param rootPath
  * @param appIntent
  * @param ui5Version
  */
-async function applyV4Templates(projectInfo, templateData, rootPath, appIntent, ui5Version) {
+async function applyV4Templates(fs, projectInfo, templateData, rootPath, appIntent, ui5Version) {
     const templateDataFlp = { ...templateData };
     templateDataFlp.project = { ...templateData.project };
     templateDataFlp.project.semanticObject = appIntent.replace('#', '');
     templateDataFlp.project.flpAppId = appIntent.replace('#', '');
-    await applyTemplates({ ...getCommonV4TemplatesMap(projectInfo.webappPath) }, templateDataFlp, rootPath, TemplateFileName.AppSettingsV4, ui5Version);
+    await applyTemplates(fs, { ...getCommonV4TemplatesMap(projectInfo.webappPath) }, templateDataFlp, rootPath, TemplateFileName.AppSettingsV4, ui5Version);
 }
 //# sourceMappingURL=application.js.map

package/dist/template/assembly.js

@@ -15,7 +15,7 @@ import { createUi5YamlConfig, createTemplateData, addV4MockMiddleware, setProjec
  * @returns Assembled template data and configurations
  */
 export async function assembleTemplateData(context) {
-    const { projectInfo, rootPath, projectData, serviceData, config, moduleInfo, ui5Config, backendConfig, libraryConfig, flags } = context;
+    const { fs, projectInfo, rootPath, projectData, serviceData, config, moduleInfo, ui5Config, backendConfig, libraryConfig, flags } = context;
     // Extract configuration values
     const { semanticObject, fullyQualifiedProjectName, fullyQualifiedProjectNameAMD, sapUiLibs, ui5Theme, sapClientParam } = config;
     const { moduleName, moduleDescription, destination } = moduleInfo;
@@ -26,14 +26,14 @@ export async function assembleTemplateData(context) {
     const isSAPApp = projectInfo.isSAPApp || false;
     const testFlpSandboxHtml = 'test/flpSandbox.html';
     // Prepare FLP sandbox configuration and intents
-    const { flpSandboxAvailable, appIntent, appMockIntent } = await prepareFlpConfiguration(projectInfo, semanticObject);
+    const { flpSandboxAvailable, appIntent, appMockIntent } = prepareFlpConfiguration(fs, projectInfo, semanticObject);
     // Generate URL parameters for different scenarios
     const urlParam = buildUrlParam(sapClientParam, disableCacheParam);
     const variantCmdUrlParam = buildUrlParam(sapClientParam, disableCacheParam, 'fiori-tools-rta-mode=true', 'sap-ui-rta-skip-flex-validation=true');
     // Read manifest.json
     let manifestJSON;
     try {
-        manifestJSON = await readManifest(rootPath, projectInfo.webappPath, projectInfo.uiAdaptation);
+        manifestJSON = await readManifest(rootPath, projectInfo.webappPath, projectInfo.uiAdaptation, fs);
     }
     catch (e) {
         throw new MigrationError(e, FileName.Manifest);
@@ -44,7 +44,7 @@ export async function assembleTemplateData(context) {
     const devDependenciesTmp = {
         ...devDependencies
     };
-    const packageJson = await generatePackageJsonConfig({
+    const packageJson = generatePackageJsonConfig(fs, {
         projectInfo,
         moduleName,
         moduleDescription,

package/dist/template/base.d.ts

@@ -1,9 +1,11 @@
 import type { FioriElementsVersion } from '../project-spec-types.js';
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo, TemplateData } from '../types.js';
 /**
  * Configuration for applying base templates
  */
 export interface ApplyBaseTemplatesConfig {
+    fs: Editor;
     projectInfo: ImportProjectInfo;
     templateData: TemplateData;
     rootPath: string;

package/dist/template/base.js

@@ -3,7 +3,6 @@ import { DirName } from '../project-spec-types.js';
 import { TemplateFileName } from '../index.js';
 import { trueCasePath } from 'true-case-path';
 import { getBaseTemplatesMap, isGenerateIndex } from '../utils/index.js';
-import { isMemFsEnabled } from '../utils/fs-adapter.js';
 import { applyTemplates } from './template-helpers.js';
 /**
  * Applies base application templates (index.html, etc.)
@@ -12,7 +11,7 @@ import { applyTemplates } from './template-helpers.js';
  * @param config - Configuration object containing all required parameters
  */
 export async function applyBaseTemplates(config) {
-    const { projectInfo, templateData, rootPath, keepIndex, internalToggle, ui5Version, FioriElementsVersionEnum } = config;
+    const { fs, projectInfo, templateData, rootPath, keepIndex, internalToggle, ui5Version, FioriElementsVersionEnum } = config;
     // Step3. Apply base application templates
     // Determine mock server filename (handle case sensitivity)
     const mockServerJsPath = join(projectInfo.rootPath, projectInfo.webappPath, DirName.LocalService, TemplateFileName.MockServer);
@@ -32,33 +31,6 @@ export async function applyBaseTemplates(config) {
             ? TemplateFileName.V4IndexHtml
             : TemplateFileName.V2IndexHtml].targetName = 'index_new.html';
     }
-    await applyTemplates(templates, templateData, rootPath, undefined, ui5Version);
-    // Step4a. Fix local service case (handle case-sensitive filesystems)
-    await fixLocalServiceCase(projectInfo);
-}
-/**
- * Fixes local service directory case on case-sensitive filesystems
- * Renames directory if case doesn't match expected case
- *
- * @param projectInfo - Project information
- */
-async function fixLocalServiceCase(projectInfo) {
-    // Skip in mem-fs mode - not supported
-    if (isMemFsEnabled()) {
-        return;
-    }
-    const localServicePath = join(projectInfo.rootPath, projectInfo.webappPath, DirName.LocalService);
-    try {
-        const localServiceRealPath = await trueCasePath(localServicePath);
-        // file exists. Check filename cases matches
-        if (basename(localServiceRealPath) !== basename(localServicePath)) {
-            // Use copy+delete pattern for mem-fs compatibility
-            const fs = await import('node:fs');
-            fs.renameSync(localServiceRealPath, localServicePath);
-        }
-    }
-    catch (error) {
-        // do nothing - path doesn't exist or other error
-    }
+    await applyTemplates(fs, templates, templateData, rootPath, undefined, ui5Version);
 }
 //# sourceMappingURL=base.js.map

package/dist/template/details.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest, ManifestNamespace, FioriElementsVersion } from '../project-spec-types.js';
 /**
  * Result of template details extraction
@@ -13,6 +14,7 @@ export interface TemplateDetailsExtractionResult {
 /**
  * Extract template details including FE version, floor plan, and app metadata from manifest and pom.xml
  *
+ * @param fs - mem-fs editor
  * @param manifest - The manifest object
  * @param projectRoot - Root path of the project
  * @param mainService - Main service name
@@ -21,5 +23,5 @@ export interface TemplateDetailsExtractionResult {
  * @param getFloorPlan - Function to get floor plan from manifest
  * @returns Template details extraction result
  */
-export declare function extractTemplateDetails(manifest: Manifest, projectRoot: string, mainService: string, existingAppVersion: string, getVersionFromManifest: (manifest: Manifest) => FioriElementsVersion | undefined, getFloorPlan: (manifest: Manifest, feVersion: FioriElementsVersion | undefined) => string): Promise<TemplateDetailsExtractionResult>;
+export declare function extractTemplateDetails(fs: Editor, manifest: Manifest, projectRoot: string, mainService: string, existingAppVersion: string, getVersionFromManifest: (manifest: Manifest) => FioriElementsVersion | undefined, getFloorPlan: (manifest: Manifest, feVersion: FioriElementsVersion | undefined) => string): TemplateDetailsExtractionResult;
 //# sourceMappingURL=details.d.ts.map

package/dist/template/details.js

@@ -9,6 +9,7 @@ import { isAppFreestyle } from '../utils/common.js';
 /**
  * Extract template details including FE version, floor plan, and app metadata from manifest and pom.xml
  *
+ * @param fs - mem-fs editor
  * @param manifest - The manifest object
  * @param projectRoot - Root path of the project
  * @param mainService - Main service name
@@ -17,12 +18,12 @@ import { isAppFreestyle } from '../utils/common.js';
  * @param getFloorPlan - Function to get floor plan from manifest
  * @returns Template details extraction result
  */
-export async function extractTemplateDetails(manifest, projectRoot, mainService, existingAppVersion, getVersionFromManifest, getFloorPlan) {
+export function extractTemplateDetails(fs, manifest, projectRoot, mainService, existingAppVersion, getVersionFromManifest, getFloorPlan) {
     const feVersion = getVersionFromManifest(manifest);
     const isSAPApp = !feVersion ? isAppFreestyle(manifest, feVersion) : false;
     const floorPlan = !isSAPApp ? getFloorPlan(manifest, feVersion) : undefined;
     const mainServiceDatasource = extractMainServiceDatasource(manifest, mainService);
-    const { sapAppId, appVersion } = await extractPomDetails(manifest, projectRoot, existingAppVersion);
+    const { sapAppId, appVersion } = extractPomDetails(fs, manifest, projectRoot, existingAppVersion);
     return {
         feVersion,
         isSAPApp,
@@ -51,19 +52,20 @@ function extractMainServiceDatasource(manifest, mainService) {
 /**
  * Extract app ID and version from pom.xml
  *
+ * @param fs - mem-fs editor
  * @param manifest
  * @param projectRoot
  * @param existingAppVersion
  */
-async function extractPomDetails(manifest, projectRoot, existingAppVersion) {
+function extractPomDetails(fs, manifest, projectRoot, existingAppVersion) {
     let sapAppId = manifest['sap.app']?.id || '';
     let appVersion = existingAppVersion;
     const pomXmlPath = join(projectRoot, TemplateFileName.Pom);
-    if (!(await fileExists(pomXmlPath))) {
+    if (!fileExists(fs, pomXmlPath)) {
         return { sapAppId, appVersion };
     }
     try {
-        const pomFileStr = readFile(pomXmlPath);
+        const pomFileStr = readFile(fs, pomXmlPath);
         const pomJSON = xmlToJson(pomFileStr);
         if (!pomJSON) {
             return { sapAppId, appVersion };

package/dist/template/template-helpers.d.ts

@@ -1,12 +1,14 @@
+import type { Editor } from 'mem-fs-editor';
 import type { TemplateData, TemplateMap } from '../types.js';
 /**
  * Applies EJS templates to generate project files
  *
+ * @param fs - mem-fs editor
  * @param templates - Map of template names to their properties
  * @param templateData - Data to populate templates with
  * @param projectRoot - Root path of the project
  * @param templateRoot - Optional root directory for templates (defaults to AppSettings)
  * @param ui5Version - Optional UI5 version for theme updates
  */
-export declare function applyTemplates(templates: TemplateMap, templateData: TemplateData, projectRoot: string, templateRoot?: string, ui5Version?: string): Promise<void>;
+export declare function applyTemplates(fs: Editor, templates: TemplateMap, templateData: TemplateData, projectRoot: string, templateRoot?: string, ui5Version?: string): Promise<void>;
 //# sourceMappingURL=template-helpers.d.ts.map

package/dist/template/template-helpers.js

@@ -6,20 +6,21 @@ import { MigrationTypes } from '../utils/constants.js';
 /**
  * Applies EJS templates to generate project files
  *
+ * @param fs - mem-fs editor
  * @param templates - Map of template names to their properties
  * @param templateData - Data to populate templates with
  * @param projectRoot - Root path of the project
  * @param templateRoot - Optional root directory for templates (defaults to AppSettings)
  * @param ui5Version - Optional UI5 version for theme updates
  */
-export async function applyTemplates(templates, templateData, projectRoot, templateRoot, ui5Version) {
+export async function applyTemplates(fs, templates, templateData, projectRoot, templateRoot, ui5Version) {
     const baseTemplateRoot = join(templatesDirPath, templateRoot || TemplateFileName.AppSettings);
     await Promise.all(Object.keys(templates).map(async (templateName) => {
         const templateProps = templates[templateName];
-        await generateTemplate(templateData, projectRoot, baseTemplateRoot, templateName, templateProps);
+        await generateTemplate(fs, templateData, projectRoot, baseTemplateRoot, templateName, templateProps);
     }));
     if (templateData.project.type === MigrationTypes.projectExtension &&
-        (await fileExists(join(projectRoot, DirName.Webapp, TemplateFileName.IndexHtml)))) {
+        fileExists(fs, join(projectRoot, DirName.Webapp, TemplateFileName.IndexHtml))) {
         // For project extensions, we usually leave the index.html file unchanged.
         // However, since the Belize theme is no longer available after UI5 version 1.136.0,
         // we need to update the `data-sap-ui-theme` attribute in the index.html file
@@ -27,9 +28,9 @@ export async function applyTemplates(templates, templateData, projectRoot, templ
         const templateName = TemplateFileName.IndexHtml;
         try {
             const htmlPath = join(projectRoot, DirName.Webapp, templateName);
-            const html = readFile(htmlPath).toString();
+            const html = readFile(fs, htmlPath).toString();
             const updatedHtml = updateThemeAttribute(html, ui5Version ?? '', templateData.project.ui5Theme ?? '');
-            updateFile(htmlPath, updatedHtml);
+            updateFile(fs, htmlPath, updatedHtml);
             return;
         }
         catch {

package/dist/template/theme.d.ts

@@ -1,11 +1,13 @@
 import type { ImportProjectInfo } from '../types.js';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Gets supported themes for the project, excluding deprecated themes.
  * Adds 'sap_bluecrystal' if not present and prefixes all with 'themelib_'.
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information containing root path and theme settings
  * @param ui5Version - UI5 version to determine excluded themes
  * @returns Array of supported theme names with 'themelib_' prefix
  */
-export declare function getSupportedThemes(projectInfo: ImportProjectInfo, ui5Version: string | undefined): Promise<string[]>;
+export declare function getSupportedThemes(fs: Editor, projectInfo: ImportProjectInfo, ui5Version: string | undefined): Promise<string[]>;
 //# sourceMappingURL=theme.d.ts.map

package/dist/template/theme.js

@@ -4,15 +4,16 @@ import { getExcludedThemes } from '../utils/UI5Theme.js';
  * Gets supported themes for the project, excluding deprecated themes.
  * Adds 'sap_bluecrystal' if not present and prefixes all with 'themelib_'.
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information containing root path and theme settings
  * @param ui5Version - UI5 version to determine excluded themes
  * @returns Array of supported theme names with 'themelib_' prefix
  */
-export async function getSupportedThemes(projectInfo, ui5Version) {
+export async function getSupportedThemes(fs, projectInfo, ui5Version) {
     let supportedThemes = [];
     // Try to read the manifest and extract supported themes
     try {
-        const manifest = await readManifest(projectInfo.rootPath, projectInfo.webappPath, projectInfo.uiAdaptation);
+        const manifest = await readManifest(projectInfo.rootPath, projectInfo.webappPath, projectInfo.uiAdaptation, fs);
         // Get supported themes, filtering out deprecated ones
         supportedThemes =
             manifest?.['sap.ui']?.supportedThemes?.filter((theme) => 

package/dist/types/mem-fs-types.d.ts

@@ -38,7 +38,7 @@ export interface MemFsStore {
  *
  * @example
  * ```typescript
- * const editor = getCurrentEditor() as EditorWithStore;
+ * const editor = fs as EditorWithStore;
  * editor.store.each((file) => {
  *     console.log(file.path);
  * });

package/dist/utils/Project.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest, Package } from '../project-spec-types.js';
 import type { ImportProjectInfo, Message, MigratableFolder, ProjectFolder } from '../types.js';
 import { MigrationTypes } from './constants.js';
@@ -10,14 +11,16 @@ export declare class ProjectAccess {
      * @param migrationType
      * @param workspaceFolders
      * @param libPath
+     * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted (standalone discovery)
      */
-    static getProjectInfo(projectRoot: string, migrationType?: MigrationTypes, workspaceFolders?: readonly ProjectFolder[], libPath?: string): Promise<{
+    static getProjectInfo(projectRoot: string, migrationType?: MigrationTypes, workspaceFolders?: readonly ProjectFolder[], libPath?: string, fsEditor?: Editor): Promise<{
         projectInfo: ImportProjectInfo;
         messages: Message[];
     }>;
     /**
      * Process project based on its type
      *
+     * @param fs - mem-fs editor
      * @param projectType - Type of project to process
      * @param projectRoot - Project root path
      * @param manifest - Project manifest
@@ -26,36 +29,36 @@ export declare class ProjectAccess {
      * @returns Processed project info and messages
      */
     private static processProjectByType;
-    static getWebappPath(projectRoot: string, type?: MigrationTypes, libPath?: string): Promise<string>;
+    static getWebappPath(projectRoot: string, type?: MigrationTypes, libPath?: string, fsEditor?: Editor): Promise<string>;
     static getManifestPath(projectRoot: string, webappPath: string): string;
     static getPackageJsonPath(projectRoot: string): string;
-    static getPackageJson(filePath: string): Promise<any>;
-    static getManifestJson(projectRoot: string, webappPath: string): Promise<Manifest>;
+    static getPackageJson(filePath: string, fsEditor?: Editor): Promise<any>;
+    static getManifestJson(projectRoot: string, webappPath: string, fsEditor?: Editor): Promise<Manifest>;
     static getVersionFromManifest(manifest: Manifest): import("../project-spec-types.js").FioriElementsVersion | undefined;
     static getSemanticObjectAction(manifest: Manifest): string | undefined;
-    static getFlpIntentFromHtml(htmlFilePath: string): Promise<string | undefined>;
+    static getFlpIntentFromHtml(htmlFilePath: string, fsEditor?: Editor): string | undefined;
     static getFloorPlan(manifest: Manifest, feVersion: any): string;
     static getMainEntity(manifest: Manifest): string;
-    static getFirstBackend(projectRoot: string): ReturnType<typeof getFirstBackend>;
-    static checkMigratableAdaptationProject(projectRoot: string): Promise<any>;
-    static checkIfReuseLib(projectRoot: string, type?: MigrationTypes, manifest?: Manifest): Promise<boolean>;
-    static readProjectExtensionSettings(projectRoot: string): Promise<unknown>;
-    static checkIfProjectExtension(projectRoot: string): Promise<boolean>;
-    static isFioriToolsAdaptationProject(projectRoot: string): Promise<boolean>;
-    static getReuseLibModuleName(projectRoot: string, workspaceFolders?: readonly ProjectFolder[], manifest?: Manifest): Promise<string>;
+    static getFirstBackend(projectRoot: string, fsEditor?: Editor): ReturnType<typeof getFirstBackend>;
+    static checkMigratableAdaptationProject(projectRoot: string, fsEditor?: Editor): Promise<any>;
+    static checkIfReuseLib(projectRoot: string, type?: MigrationTypes, manifest?: Manifest, fsEditor?: Editor): Promise<boolean>;
+    static readProjectExtensionSettings(projectRoot: string, fsEditor?: Editor): Promise<unknown>;
+    static checkIfProjectExtension(projectRoot: string, fsEditor?: Editor): Promise<boolean>;
+    static isFioriToolsAdaptationProject(projectRoot: string, fsEditor?: Editor): boolean;
+    static getReuseLibModuleName(projectRoot: string, workspaceFolders?: readonly ProjectFolder[], manifest?: Manifest, fsEditor?: Editor): Promise<string>;
     static getExtensionProjectModuleName(projectRoot: string, projectSettings: any, manifest?: Manifest): string;
     static getNeoAppData(neoAppJson: any, destination: string, isUiAdaptation?: boolean): {
         destination: string;
         neoAppUI5Version: string | undefined;
         neoappDestinations: import("../migration-types.js").NeoappDestination[];
     };
-    static getDestinationFromNeoApp(projectRoot: string, destinationIn: string): Promise<{
+    static getDestinationFromNeoApp(projectRoot: string, destinationIn: string, fsEditor?: Editor): Promise<{
         destination: string;
         neoAppUI5Version?: string;
         neoappDestinations?: import("../migration-types.js").NeoappDestination[];
     } | undefined>;
     static getClientFromDestinationName(destination: string): string;
-    static getProjectRoots(workspaceRoots: readonly ProjectFolder[], sapuxRequired?: boolean): Promise<MigratableFolder[]>;
+    static getProjectRoots(workspaceRoots: readonly ProjectFolder[], sapuxRequired?: boolean, fsEditor?: Editor): Promise<MigratableFolder[]>;
     static hasUI5Tooling(packageJSON?: Package): boolean;
 }
 //# sourceMappingURL=Project.d.ts.map