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

package/dist/utils/Project.js

@@ -1,4 +1,5 @@
 import { dirname, join, relative, sep } from 'node:path';
+import { createMemFsEditor } from './fs-adapter.js';
 import { getReuseLibs, findAllProjectRoots, ReuseLibType } from './file-discovery.js';
 import { DirName } from '../project-spec-types.js';
 import { legacyPath, findAllWebIDEProjectFolders, findProjectsByManifest } from './common.js';
@@ -11,18 +12,19 @@ import { processRegularProject } from '../project/regular-project.js';
 import { processReuseLibrary } from '../project/reuse-library.js';
 import { i18nText } from '../i18n.js';
 // Import extracted readers and utilities
-import { getWebappPath, getManifestJson, getManifestPath, getPackageJson, getPackageJsonPath, getVersionFromManifest, getSemanticObjectAction, getFlpIntentFromHtml, getFloorPlan, getMainEntity, getFirstBackend, checkMigratableAdaptationProject, isFioriToolsAdaptationProject, readProjectExtensionSettings, checkIfProjectExtension, getExtensionProjectModuleName, checkIfReuseLib, findNestedReuseLibManifest, getReuseLibModuleName, isSamePath, getClientFromDestinationName, getNeoAppData, getDestinationFromNeoApp } from './project-readers/index.js';
+import { getWebappPath, getManifestJson, getManifestPath, getPackageJson, getPackageJsonPath, getVersionFromManifest, getSemanticObjectAction, getFlpIntentFromHtml, getFloorPlan, getMainEntity, getFirstBackend, checkMigratableAdaptationProject, isFioriToolsAdaptationProject, readProjectExtensionSettings, checkIfProjectExtension, getExtensionProjectModuleName, checkIfReuseLib, findNestedReuseLibManifest, getReuseLibModuleName, getClientFromDestinationName, getNeoAppData, getDestinationFromNeoApp, isSamePath } from './project-readers/index.js';
 /**
  * Try to load manifest from standard or legacy paths
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Project root path
  * @param webappPath - Webapp path
  * @returns Manifest and updated webapp path, or undefined if not found
  */
-async function tryLoadManifest(projectRoot, webappPath) {
+async function tryLoadManifest(fs, projectRoot, webappPath) {
     // Try standard location first
     try {
-        const manifest = await getManifestJson(projectRoot, webappPath);
+        const manifest = await getManifestJson(fs, projectRoot, webappPath);
         return { manifest, updatedWebappPath: webappPath };
     }
     catch {
@@ -30,7 +32,7 @@ async function tryLoadManifest(projectRoot, webappPath) {
     }
     // Try legacy path
     try {
-        const manifest = await getManifestJson(join(projectRoot, legacyPath), webappPath);
+        const manifest = await getManifestJson(fs, join(projectRoot, legacyPath), webappPath);
         return { manifest, updatedWebappPath: join(legacyPath, webappPath) };
     }
     catch {
@@ -41,11 +43,12 @@ async function tryLoadManifest(projectRoot, webappPath) {
 /**
  * Try to find manifest in nested reuse lib structure
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Project root path
  * @returns Manifest and webapp path if found
  */
-async function tryFindNestedLibManifest(projectRoot) {
-    const nestedLib = await findNestedReuseLibManifest(projectRoot);
+async function tryFindNestedLibManifest(fs, projectRoot) {
+    const nestedLib = await findNestedReuseLibManifest(fs, projectRoot);
     if (nestedLib) {
         return {
             manifest: nestedLib.manifest,
@@ -57,6 +60,7 @@ async function tryFindNestedLibManifest(projectRoot) {
 /**
  * Handle manifest resolution when no manifest was found in standard locations
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Project root path
  * @param migrationType - Migration type
  * @param isProjectExtension - Whether project is an extension
@@ -64,13 +68,13 @@ async function tryFindNestedLibManifest(projectRoot) {
  * @param checkIfReuseLib - Function to check if reuse library
  * @returns Resolution result with manifest, webappPath, isReuseLib flag, and messages
  */
-async function resolveManifestForUnknownProject(projectRoot, migrationType, isProjectExtension, checkMigratableAdaptationProject, checkIfReuseLib) {
+async function resolveManifestForUnknownProject(fs, projectRoot, migrationType, isProjectExtension, checkMigratableAdaptationProject, checkIfReuseLib) {
     const messages = [];
     let isReuseLib = await checkIfReuseLib(projectRoot, migrationType);
     let manifest;
     let webappPath;
     if (!isReuseLib && !isProjectExtension) {
-        const nestedLib = await tryFindNestedLibManifest(projectRoot);
+        const nestedLib = await tryFindNestedLibManifest(fs, projectRoot);
         if (nestedLib) {
             manifest = nestedLib.manifest;
             webappPath = nestedLib.webappPath;
@@ -135,8 +139,10 @@ export class ProjectAccess {
      * @param migrationType
      * @param workspaceFolders
      * @param libPath
+     * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted (standalone discovery)
      */
-    static async getProjectInfo(projectRoot, migrationType, workspaceFolders, libPath) {
+    static async getProjectInfo(projectRoot, migrationType, workspaceFolders, libPath, fsEditor) {
+        const fs = fsEditor ?? createMemFsEditor();
         let manifest;
         let messages = [];
         let isReuseLib;
@@ -146,18 +152,18 @@ export class ProjectAccess {
             hasRootIntent: { ...defaultProjectInfo.hasRootIntent }
         };
         // Get initial webapp path
-        projectInfo.webappPath = await this.getWebappPath(projectRoot, migrationType, libPath);
+        projectInfo.webappPath = await this.getWebappPath(projectRoot, migrationType, libPath, fs);
         // Try to load manifest from standard or legacy paths
-        const manifestResult = await tryLoadManifest(projectRoot, projectInfo.webappPath);
+        const manifestResult = await tryLoadManifest(fs, projectRoot, projectInfo.webappPath);
         if (manifestResult) {
             manifest = manifestResult.manifest;
             projectInfo.webappPath = manifestResult.updatedWebappPath;
         }
         // Check project type flags
-        const isProjectExtension = await this.checkIfProjectExtension(projectRoot);
+        const isProjectExtension = await this.checkIfProjectExtension(projectRoot, fs);
         // If no manifest found, resolve from unknown project structure
         if (!manifest) {
-            const resolution = await resolveManifestForUnknownProject(projectRoot, migrationType, isProjectExtension, this.checkMigratableAdaptationProject.bind(this), this.checkIfReuseLib.bind(this));
+            const resolution = await resolveManifestForUnknownProject(fs, projectRoot, migrationType, isProjectExtension, (root) => this.checkMigratableAdaptationProject(root, fs), (root, type) => this.checkIfReuseLib(root, type, undefined, fs));
             manifest = resolution.manifest;
             if (resolution.webappPath) {
                 projectInfo.webappPath = resolution.webappPath;
@@ -166,13 +172,13 @@ export class ProjectAccess {
             messages = messages.concat(resolution.messages);
         }
         // Determine reuse lib status if not yet known
-        isReuseLib ??= await this.checkIfReuseLib(projectRoot, migrationType, manifest);
+        isReuseLib ??= await this.checkIfReuseLib(projectRoot, migrationType, manifest, fs);
         // Check adaptation project status
-        const adaptationCheck = await this.checkMigratableAdaptationProject(projectRoot);
+        const adaptationCheck = await this.checkMigratableAdaptationProject(projectRoot, fs);
         const isAdaptationProject = adaptationCheck?.reference !== undefined;
         // Process based on project type
         const projectType = determineProjectType(isReuseLib, isProjectExtension, isAdaptationProject, manifest);
-        const result = await this.processProjectByType(projectType, projectRoot, manifest, projectInfo, workspaceFolders);
+        const result = await this.processProjectByType(fs, projectType, projectRoot, manifest, projectInfo, workspaceFolders);
         projectInfo = result.projectInfo;
         messages = messages.concat(result.messages);
         return { projectInfo, messages };
@@ -180,6 +186,7 @@ export class ProjectAccess {
     /**
      * 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
@@ -187,17 +194,18 @@ export class ProjectAccess {
      * @param workspaceFolders - Workspace folders
      * @returns Processed project info and messages
      */
-    static async processProjectByType(projectType, projectRoot, manifest, projectInfo, workspaceFolders) {
+    static async processProjectByType(fs, projectType, projectRoot, manifest, projectInfo, workspaceFolders) {
         switch (projectType) {
             case 'regular':
                 return processRegularProject({
+                    fs,
                     projectRoot,
                     manifest: manifest,
                     defaultProjectInfo,
                     projectInfo,
                     services: {
                         projectData: {
-                            getPackageJson: this.getPackageJson.bind(this),
+                            getPackageJson: (filePath) => this.getPackageJson(filePath, fs),
                             getMainEntity: this.getMainEntity.bind(this),
                             hasUI5Tooling: this.hasUI5Tooling.bind(this)
                         },
@@ -207,18 +215,28 @@ export class ProjectAccess {
                             getFloorPlan: this.getFloorPlan.bind(this)
                         },
                         backendConfig: {
-                            getFirstBackend: this.getFirstBackend.bind(this),
-                            getFlpIntentFromHtml: this.getFlpIntentFromHtml.bind(this),
-                            getDestinationFromNeoApp: this.getDestinationFromNeoApp.bind(this),
+                            getFirstBackend: (root) => this.getFirstBackend(root, fs),
+                            getFlpIntentFromHtml: (htmlFilePath) => this.getFlpIntentFromHtml(htmlFilePath, fs),
+                            getDestinationFromNeoApp: (root, destinationIn) => this.getDestinationFromNeoApp(root, destinationIn, fs),
                             getClientFromDestinationName: this.getClientFromDestinationName.bind(this)
                         }
                     }
                 });
-            case 'reuseLib':
+            case 'reuseLib': {
+                const reuseLibInfo = await processReuseLibrary(projectRoot, defaultProjectInfo, workspaceFolders, manifest, (filePath) => this.getPackageJson(filePath, fs), this.hasUI5Tooling.bind(this), (root, folders, mf) => this.getReuseLibModuleName(root, folders, mf, fs));
                 return {
-                    projectInfo: await processReuseLibrary(projectRoot, defaultProjectInfo, workspaceFolders, manifest, this.getPackageJson.bind(this), this.hasUI5Tooling.bind(this), this.getReuseLibModuleName.bind(this)),
+                    // Preserve the webappPath resolved before processReuseLibrary (e.g. from .project.json)
+                    // and set the default targetMockHtmlFile for libraries.
+                    projectInfo: {
+                        ...reuseLibInfo,
+                        webappPath: projectInfo.webappPath !== DirName.Webapp
+                            ? projectInfo.webappPath
+                            : reuseLibInfo.webappPath,
+                        targetMockHtmlFile: 'test/flpSandboxMockServer.html'
+                    },
                     messages: []
                 };
+            }
             case 'extension':
                 return {
                     projectInfo: await processProjectExtension({
@@ -226,15 +244,15 @@ export class ProjectAccess {
                         defaultProjectInfo,
                         projectInfo,
                         manifest,
-                        getPackageJson: this.getPackageJson.bind(this),
+                        getPackageJson: (filePath) => this.getPackageJson(filePath, fs),
                         hasUI5Tooling: this.hasUI5Tooling.bind(this),
-                        readProjectExtensionSettings: this.readProjectExtensionSettings.bind(this),
+                        readProjectExtensionSettings: (root) => this.readProjectExtensionSettings(root, fs),
                         getExtensionProjectModuleName: this.getExtensionProjectModuleName.bind(this),
-                        getDestinationFromNeoApp: this.getDestinationFromNeoApp.bind(this),
-                        getFirstBackend: this.getFirstBackend.bind(this),
+                        getDestinationFromNeoApp: (root, destinationIn) => this.getDestinationFromNeoApp(root, destinationIn, fs),
+                        getFirstBackend: (root) => this.getFirstBackend(root, fs),
                         getClientFromDestinationName: this.getClientFromDestinationName.bind(this),
-                        getFlpIntentFromHtml: this.getFlpIntentFromHtml.bind(this),
-                        getManifestJson: this.getManifestJson.bind(this)
+                        getFlpIntentFromHtml: (htmlFilePath) => this.getFlpIntentFromHtml(htmlFilePath, fs),
+                        getManifestJson: (root, webappPath) => this.getManifestJson(root, webappPath, fs)
                     }),
                     messages: []
                 };
@@ -245,12 +263,12 @@ export class ProjectAccess {
                         projectRoot,
                         defaultProjectInfo,
                         projectInfo,
-                        checkMigratableAdaptationProject: this.checkMigratableAdaptationProject.bind(this),
-                        getPackageJson: this.getPackageJson.bind(this),
+                        checkMigratableAdaptationProject: (root) => this.checkMigratableAdaptationProject(root, fs),
+                        getPackageJson: (filePath) => this.getPackageJson(filePath, fs),
                         hasUI5Tooling: this.hasUI5Tooling.bind(this),
-                        getDestinationFromNeoApp: this.getDestinationFromNeoApp.bind(this),
+                        getDestinationFromNeoApp: (root, destinationIn) => this.getDestinationFromNeoApp(root, destinationIn, fs),
                         getClientFromDestinationName: this.getClientFromDestinationName.bind(this),
-                        getFirstBackend: this.getFirstBackend.bind(this)
+                        getFirstBackend: (root) => this.getFirstBackend(root, fs)
                     }),
                     messages: []
                 };
@@ -258,8 +276,8 @@ export class ProjectAccess {
     }
     // ========== Delegated Methods to Utilities ==========
     // These methods delegate to extracted utility modules for better organization
-    static async getWebappPath(projectRoot, type, libPath) {
-        return getWebappPath(projectRoot, type, libPath);
+    static async getWebappPath(projectRoot, type, libPath, fsEditor) {
+        return getWebappPath(fsEditor ?? createMemFsEditor(), projectRoot, type, libPath);
     }
     static getManifestPath(projectRoot, webappPath) {
         return getManifestPath(projectRoot, webappPath);
@@ -267,11 +285,11 @@ export class ProjectAccess {
     static getPackageJsonPath(projectRoot) {
         return getPackageJsonPath(projectRoot);
     }
-    static getPackageJson(filePath) {
-        return getPackageJson(filePath);
+    static getPackageJson(filePath, fsEditor) {
+        return getPackageJson(fsEditor ?? createMemFsEditor(), filePath);
     }
-    static async getManifestJson(projectRoot, webappPath) {
-        return getManifestJson(projectRoot, webappPath);
+    static async getManifestJson(projectRoot, webappPath, fsEditor) {
+        return getManifestJson(fsEditor ?? createMemFsEditor(), projectRoot, webappPath);
     }
     static getVersionFromManifest(manifest) {
         return getVersionFromManifest(manifest);
@@ -279,8 +297,8 @@ export class ProjectAccess {
     static getSemanticObjectAction(manifest) {
         return getSemanticObjectAction(manifest);
     }
-    static async getFlpIntentFromHtml(htmlFilePath) {
-        return getFlpIntentFromHtml(htmlFilePath);
+    static getFlpIntentFromHtml(htmlFilePath, fsEditor) {
+        return getFlpIntentFromHtml(fsEditor ?? createMemFsEditor(), htmlFilePath);
     }
     static getFloorPlan(manifest, feVersion) {
         return getFloorPlan(manifest, feVersion);
@@ -288,26 +306,26 @@ export class ProjectAccess {
     static getMainEntity(manifest) {
         return getMainEntity(manifest);
     }
-    static getFirstBackend(projectRoot) {
-        return getFirstBackend(projectRoot);
+    static getFirstBackend(projectRoot, fsEditor) {
+        return getFirstBackend(fsEditor ?? createMemFsEditor(), projectRoot);
     }
-    static async checkMigratableAdaptationProject(projectRoot) {
-        return checkMigratableAdaptationProject(projectRoot);
+    static async checkMigratableAdaptationProject(projectRoot, fsEditor) {
+        return checkMigratableAdaptationProject(fsEditor ?? createMemFsEditor(), projectRoot);
     }
-    static async checkIfReuseLib(projectRoot, type, manifest) {
-        return checkIfReuseLib(projectRoot, type, manifest);
+    static async checkIfReuseLib(projectRoot, type, manifest, fsEditor) {
+        return checkIfReuseLib(projectRoot, type, manifest, fsEditor ?? createMemFsEditor());
     }
-    static async readProjectExtensionSettings(projectRoot) {
-        return readProjectExtensionSettings(projectRoot);
+    static async readProjectExtensionSettings(projectRoot, fsEditor) {
+        return readProjectExtensionSettings(fsEditor ?? createMemFsEditor(), projectRoot);
     }
-    static async checkIfProjectExtension(projectRoot) {
-        return checkIfProjectExtension(projectRoot);
+    static async checkIfProjectExtension(projectRoot, fsEditor) {
+        return checkIfProjectExtension(fsEditor ?? createMemFsEditor(), projectRoot);
     }
-    static async isFioriToolsAdaptationProject(projectRoot) {
-        return isFioriToolsAdaptationProject(projectRoot);
+    static isFioriToolsAdaptationProject(projectRoot, fsEditor) {
+        return isFioriToolsAdaptationProject(fsEditor ?? createMemFsEditor(), projectRoot);
     }
-    static async getReuseLibModuleName(projectRoot, workspaceFolders, manifest) {
-        return getReuseLibModuleName(projectRoot, workspaceFolders, manifest);
+    static async getReuseLibModuleName(projectRoot, workspaceFolders, manifest, fsEditor) {
+        return getReuseLibModuleName(projectRoot, workspaceFolders, manifest, fsEditor ?? createMemFsEditor());
     }
     static getExtensionProjectModuleName(projectRoot, projectSettings, manifest) {
         return getExtensionProjectModuleName(projectRoot, projectSettings, manifest);
@@ -315,19 +333,20 @@ export class ProjectAccess {
     static getNeoAppData(neoAppJson, destination, isUiAdaptation = false) {
         return getNeoAppData(neoAppJson, destination, isUiAdaptation);
     }
-    static async getDestinationFromNeoApp(projectRoot, destinationIn) {
-        return getDestinationFromNeoApp(projectRoot, destinationIn);
+    static async getDestinationFromNeoApp(projectRoot, destinationIn, fsEditor) {
+        return getDestinationFromNeoApp(fsEditor ?? createMemFsEditor(), projectRoot, destinationIn);
     }
     static getClientFromDestinationName(destination) {
         return getClientFromDestinationName(destination);
     }
     // ========== Core Methods (Not Delegated) ==========
-    static async getProjectRoots(workspaceRoots, sapuxRequired = false) {
+    static async getProjectRoots(workspaceRoots, sapuxRequired = false, fsEditor) {
+        const fs = fsEditor ?? createMemFsEditor();
         // find projects by package.json and pom.xml
         // Convert ProjectFolder[] to string[] for project-access functions
         const workspaceRootPaths = workspaceRoots.map((folder) => folder.uri.fsPath);
-        const packageRoots = await findAllProjectRoots(workspaceRootPaths, sapuxRequired);
-        const pomRoots = await findAllWebIDEProjectFolders(workspaceRoots);
+        const packageRoots = await findAllProjectRoots(fs, workspaceRootPaths, sapuxRequired);
+        const pomRoots = await findAllWebIDEProjectFolders(fs, workspaceRoots);
         // find projects by manifest.json in the root
         let manifestRoots = await findProjectsByManifest(workspaceRoots);
         // A root can be discovered by more than one strategy (e.g. a project with both package.json
@@ -347,7 +366,7 @@ export class ProjectAccess {
             };
         });
         // find reuse libs
-        let reuseLibsRoots = (await getReuseLibs(rootFolders)).filter((lib) => lib.value.type === ReuseLibType.LIBRARY);
+        let reuseLibsRoots = (await getReuseLibs(fs, rootFolders)).filter((lib) => lib.value.type === ReuseLibType.LIBRARY);
         // Roots that are themselves reuse libraries must be emitted only as libraries, never also as
         // plain projects. getReuseLibs assigns a nested library to its nearest package/pom root, so a
         // freestyle app that merely embeds a library shares that libRoot — suppressing by libRoot alone
@@ -360,17 +379,18 @@ export class ProjectAccess {
         if (reuseLibsRoots.length) {
             const reuseLibRootPaths = new Set(reuseLibsRoots.map((lib) => lib.value.libRoot));
             const appRoots = [];
-            // Fetch all project info in parallel for performance
-            const projectInfoResults = await Promise.all(roots.map((root) => this.getProjectInfo(root)));
-            for (let i = 0; i < roots.length; i++) {
-                const root = roots[i];
-                const result = projectInfoResults[i];
-                const isApp = !!(result.projectInfo.FEVersion || result.projectInfo.isSAPApp);
+            // Resolve project info for all roots in parallel (independent lookups).
+            const rootInfos = await Promise.all(roots.map(async (root) => ({
+                root,
+                info: (await this.getProjectInfo(root, undefined, undefined, undefined, fs)).projectInfo
+            })));
+            for (const { root, info } of rootInfos) {
+                const isApp = !!(info.FEVersion || info.isSAPApp);
                 if (isApp) {
                     appRoots.push(root);
                 }
                 else if ([...reuseLibRootPaths].some((libRoot) => isSamePath(libRoot, root)) ||
-                    result.projectInfo.type === MigrationTypes.library) {
+                    info.type === MigrationTypes.library) {
                     libraryOnlyRoots.add(root);
                 }
             }
@@ -388,14 +408,16 @@ export class ProjectAccess {
         });
         // A single library root can contain several nested manifest.json files (the library manifest
         // plus per-component manifests), each of which getReuseLibs resolves back to the same libRoot.
-        // Emit one entry per library root so the webview does not list the same library multiple times.
-        const seenLibPaths = [];
+        // The emitted entry is keyed on libRoot (root: lib.value.libRoot), so deduplicate on libRoot —
+        // not on lib.value.path, which is distinct per nested manifest and would let the same library
+        // through multiple times. Keep the first occurrence so libRoot/libPath stay paired (PR #39527).
+        const seenLibRoots = [];
         const reuseLibsUnique = reuseLibsRoots
             .filter((lib) => {
-            if (seenLibPaths.some((path) => isSamePath(path, lib.value.path))) {
+            if (seenLibRoots.some((libRoot) => isSamePath(libRoot, lib.value.libRoot))) {
                 return false;
             }
-            seenLibPaths.push(lib.value.path);
+            seenLibRoots.push(lib.value.libRoot);
             return true;
         })
             .map((lib) => {

package/dist/utils/checkForMigration.d.ts

@@ -1,5 +1,6 @@
+import type { Editor } from 'mem-fs-editor';
 import type { MigrationTypes } from './constants.js';
-export declare const readMigrationSettingsFile: () => Promise<any>;
-export declare const readMigrationSettingsFileIgnoreProjects: () => Promise<string[]>;
-export declare const checkForMigration: (projectRoot: string, type: MigrationTypes, libPath?: string) => Promise<boolean>;
+export declare const readMigrationSettingsFile: (fsEditor?: Editor) => Promise<any>;
+export declare const readMigrationSettingsFileIgnoreProjects: (fsEditor?: Editor) => Promise<string[]>;
+export declare const checkForMigration: (projectRoot: string, type: MigrationTypes, libPath?: string, fsEditor?: Editor) => Promise<boolean>;
 //# sourceMappingURL=checkForMigration.d.ts.map

package/dist/utils/checkForMigration.js

@@ -2,23 +2,26 @@ import { ProjectAccess } from './Project.js';
 import { join } from 'node:path';
 import { getFioriToolsDirectory } from '@sap-ux/store';
 import { FileName, FioriToolsSettings } from '@sap-ux/project-access';
+import { createMemFsEditor } from './fs-adapter.js';
 import { hasDependency, readJSON, findProjectRoot } from './index.js';
-export const readMigrationSettingsFile = async () => {
+export const readMigrationSettingsFile = async (fsEditor) => {
+    const fs = fsEditor ?? createMemFsEditor();
     let migrationSettingsFile;
     try {
-        migrationSettingsFile = await readJSON(join(getFioriToolsDirectory(), FioriToolsSettings.migrationSettingsFile));
+        migrationSettingsFile = await readJSON(fs, join(getFioriToolsDirectory(), FioriToolsSettings.migrationSettingsFile));
     }
     catch (error) {
         migrationSettingsFile = {};
     }
     return migrationSettingsFile;
 };
-export const readMigrationSettingsFileIgnoreProjects = async () => {
-    const migrationSettingsFile = await readMigrationSettingsFile();
+export const readMigrationSettingsFileIgnoreProjects = async (fsEditor) => {
+    const migrationSettingsFile = await readMigrationSettingsFile(fsEditor);
     migrationSettingsFile.ignoreProjects = migrationSettingsFile?.ignoreProjects ?? [];
     return migrationSettingsFile?.ignoreProjects;
 };
-export const checkForMigration = async (projectRoot, type, libPath) => {
+export const checkForMigration = async (projectRoot, type, libPath, fsEditor) => {
+    const fs = fsEditor ?? createMemFsEditor();
     let project = {
         projectInfo: {},
         messages: []
@@ -26,8 +29,8 @@ export const checkForMigration = async (projectRoot, type, libPath) => {
     let packageJson;
     let hasUi5Tooling = false;
     try {
-        project = await ProjectAccess.getProjectInfo(projectRoot, type, undefined, libPath);
-        packageJson = await readJSON(join(projectRoot, FileName.Package));
+        project = await ProjectAccess.getProjectInfo(projectRoot, type, undefined, libPath, fs);
+        packageJson = await readJSON(fs, join(projectRoot, FileName.Package));
         hasUi5Tooling =
             hasDependency(packageJson, '@sap-ux/ui5-tooling') || hasDependency(packageJson, '@sap/ux-ui5-tooling');
     }
@@ -48,7 +51,7 @@ export const checkForMigration = async (projectRoot, type, libPath) => {
         Array.isArray(project.projectInfo.sapux) ||
         project.messages.length > 0 ||
         hasUi5Tooling === true ||
-        (await readMigrationSettingsFileIgnoreProjects()).includes(projectRoot) ||
+        (await readMigrationSettingsFileIgnoreProjects(fs)).includes(projectRoot) ||
         sapUXProjectRoot !== projectRoot);
     return migratable;
 };

package/dist/utils/file-access.d.ts

@@ -1,58 +1,60 @@
 import type { Editor } from 'mem-fs-editor';
 /**
- * Read a text file
+ * Read a text file.
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param path - Path to file (if first param is Editor)
+ * @param fs - mem-fs editor
+ * @param path - Path to file
  * @returns File contents as string
  */
-export declare function readFile(pathOrFs: string | Editor, path?: string): string;
+export declare function readFile(fs: Editor, path: string): string;
 /**
- * Read a JSON file
+ * Read and parse a JSON file, preserving indentation metadata (Symbol(indent))
+ * so that a later updateJSON can keep the original formatting.
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param path - Path to file (if first param is Editor)
+ * @param fs - mem-fs editor
+ * @param path - Path to file
  * @returns Parsed JSON object
  */
-export declare function readJSON<T = any>(pathOrFs: string | Editor, path?: string): Promise<T>;
+export declare function readJSON<T = any>(fs: Editor, path: string): T;
 /**
- * Check if a file exists
+ * Check if a file or directory exists (staged in mem-fs or present on the real filesystem).
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param path - Path to file (if first param is Editor)
- * @returns true if file exists, false otherwise
+ * Unlike mem-fs's `editor.exists()`, this also reports directories as present — many migration
+ * checks test for folders (e.g. the webapp directory) — and reads through to the real filesystem
+ * so files not yet staged in mem-fs are still seen.
+ *
+ * @param fs - mem-fs editor
+ * @param path - Path to file or directory
+ * @returns true if the path exists
  */
-export declare function fileExists(pathOrFs: string | Editor, path?: string): Promise<boolean>;
+export declare function fileExists(fs: Editor, path: string): boolean;
 /**
- * Write a text file
+ * Write a text file.
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param contentOrPath - Content to write, or path (if first param is Editor)
- * @param content - Content to write (if first param is Editor)
+ * @param fs - mem-fs editor
+ * @param path - Path to file
+ * @param content - Content to write
  */
-export declare function writeFile(pathOrFs: string | Editor, contentOrPath: string, content?: string): void;
+export declare function writeFile(fs: Editor, path: string, content: string): void;
 /**
- * Update a text file
- * Alias for writeFile for backward compatibility
- *
- * @param pathOrFs - Path to file, or Editor instance
- * @param contentOrPath - Content to write, or path (if first param is Editor)
- * @param content - Content to write (if first param is Editor)
+ * Update a text file. Alias of writeFile; kept as a distinct name for call-site clarity
+ * (updating an existing file vs. creating a new one).
  */
-export declare function updateFile(pathOrFs: string | Editor, contentOrPath: string, content?: string): void;
+export declare const updateFile: typeof writeFile;
 /**
- * Update a JSON file while preserving indentation
+ * Update a JSON file while preserving the indentation of the existing file.
+ * New files are written with 4-space indentation and a trailing newline.
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param contentOrPath - Object to write, or path (if first param is Editor)
- * @param _content - Object to write (if first param is Editor)
+ * @param fs - mem-fs editor
+ * @param path - Path to file
+ * @param content - Object to serialize
  */
-export declare function updateJSON(pathOrFs: string | Editor, contentOrPath: string | object, _content?: object): void;
+export declare function updateJSON(fs: Editor, path: string, content: object): void;
 /**
- * Delete a file
+ * Delete a file.
  *
- * @param pathOrFs - Path to file, or Editor instance
- * @param path - Path to file (if first param is Editor)
+ * @param fs - mem-fs editor
+ * @param path - Path to file
  */
-export declare function deleteFile(pathOrFs: string | Editor, path?: string): void;
+export declare function deleteFile(fs: Editor, path: string): void;
 //# sourceMappingURL=file-access.d.ts.map