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

package/dist/utils/file-access.js

@@ -1,134 +1,102 @@
 /**
- * File access utilities using mem-fs-editor
+ * File access utilities backed by a mem-fs editor.
  *
- * Uses editor from AsyncLocalStorage context set by runWithEditor().
- * Functions can also accept an explicit Editor parameter for backward compatibility.
- * If no editor is in context or provided, creates a temporary one (for tests/direct usage).
+ * Every function takes the editor explicitly as its first argument, matching the
+ * convention used across the other open-ux-tools writer packages. mem-fs reads from
+ * the real filesystem on a cache miss, so these work for both staged and on-disk files.
  */
 // @ts-expect-error - no type definitions available
 import parseJson from 'json-parse-even-better-errors';
-import { readFile as fsReadFile, access } from 'node:fs/promises';
-import { editorHasPath, getCurrentEditor, exists as fsAdapterExists, getEditor } from './fs-adapter.js';
+import { existsSync } from 'node:fs';
+import { editorHasPath } from './fs-adapter.js';
 /**
- * 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 function readFile(pathOrFs, path) {
-    const fs = getEditor(pathOrFs);
-    const filePath = typeof pathOrFs === 'string' ? pathOrFs : path;
-    return fs.read(filePath);
+export function readFile(fs, path) {
+    return fs.read(path);
 }
 /**
- * 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 async function readJSON(pathOrFs, path) {
-    const filePath = typeof pathOrFs === 'string' ? pathOrFs : path;
-    // When called with just a path string and no editor context, read from filesystem directly
-    // This keeps behavior consistent with fileExists which also falls back to real filesystem
-    let content;
-    if (typeof pathOrFs === 'string' && !getCurrentEditor()) {
-        content = await fsReadFile(filePath, 'utf-8');
-    }
-    else {
-        const fs = getEditor(pathOrFs);
-        content = fs.read(filePath);
-    }
-    return JSON.parse(content);
-}
-/**
- * Check if a file exists
- *
- * @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
- */
-export async function fileExists(pathOrFs, path) {
-    // String path: delegate to the single shared existence check (mem-fs staged OR real fs).
-    if (typeof pathOrFs === 'string') {
-        return fsAdapterExists(pathOrFs);
-    }
-    // Explicit editor argument: check that editor's staged files, then fall back to real fs.
-    // The real-fs fallback prevents overwriting files not yet loaded into the given editor
-    // (e.g., the mockserver.js overwrite bug).
-    const filePath = path;
-    if (editorHasPath(pathOrFs, filePath)) {
-        return true;
-    }
+export function readJSON(fs, path) {
+    const content = fs.read(path);
+    const result = JSON.parse(content);
     try {
-        await access(filePath);
-        return true;
+        const withIndent = parseJson(content);
+        const indent = Symbol.for('indent');
+        if (withIndent[indent]) {
+            result[indent] = withIndent[indent];
+        }
     }
     catch {
-        return false;
+        // JSON.parse already succeeded; indentation metadata is best-effort.
     }
+    return result;
 }
 /**
- * Write a text file
+ * 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 contentOrPath - Content to write, or path (if first param is Editor)
- * @param content - Content to write (if first param is Editor)
+ * 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 function writeFile(pathOrFs, contentOrPath, content) {
-    const fs = getEditor(pathOrFs);
-    const filePath = typeof pathOrFs === 'string' ? pathOrFs : contentOrPath;
-    const fileContent = typeof pathOrFs === 'string' ? contentOrPath : content;
-    fs.write(filePath, fileContent);
+export function fileExists(fs, path) {
+    return editorHasPath(fs, path) || existsSync(path);
 }
 /**
- * Update a text file
- * Alias for writeFile for backward compatibility
+ * 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 function updateFile(pathOrFs, contentOrPath, content) {
-    writeFile(pathOrFs, contentOrPath, content);
+export function writeFile(fs, path, content) {
+    fs.write(path, content);
 }
 /**
- * Update a JSON file while preserving indentation
+ * 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 const updateFile = writeFile;
+/**
+ * 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 function updateJSON(pathOrFs, contentOrPath, _content) {
-    const fs = getEditor(pathOrFs);
-    const filePath = typeof pathOrFs === 'string' ? pathOrFs : contentOrPath;
-    const fileContent = typeof pathOrFs === 'string' ? contentOrPath : _content;
+export function updateJSON(fs, path, content) {
     try {
-        // Read old contents and indentation of the JSON file
-        const oldContentText = fs.read(filePath);
-        const oldContentJson = parseJson(oldContentText);
+        const oldContentJson = parseJson(fs.read(path));
         const indent = Symbol.for('indent');
-        // Prepare new JSON file content with previous indentation
-        const result = JSON.stringify(fileContent, null, oldContentJson[indent]) + '\n';
-        fs.write(filePath, result);
+        fs.write(path, JSON.stringify(content, null, oldContentJson[indent]) + '\n');
     }
     catch {
-        // Expected: file may not exist yet or may contain invalid JSON (new file creation scenario).
-        // Safe to write with default 4-space indentation and trailing newline - this is the standard format.
-        const newContent = JSON.stringify(fileContent, null, 4) + '\n';
-        fs.write(filePath, newContent);
+        // Expected: file may not exist yet or may contain invalid JSON (new file creation).
+        fs.write(path, JSON.stringify(content, null, 4) + '\n');
     }
 }
 /**
- * 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 function deleteFile(pathOrFs, path) {
-    const fs = getEditor(pathOrFs);
-    const filePath = typeof pathOrFs === 'string' ? pathOrFs : path;
-    fs.delete(filePath);
+export function deleteFile(fs, path) {
+    fs.delete(path);
 }
 //# sourceMappingURL=file-access.js.map

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

@@ -4,6 +4,7 @@
  * Replaces @sap/ux-project-access file discovery functions with native implementations
  * using fast-glob and Node.js fs APIs.
  */
+import type { Editor } from 'mem-fs-editor';
 import type { ProjectFolder } from '../types.js';
 /**
  * Reuse library type enum
@@ -19,11 +20,12 @@ export type ReuseLibType = (typeof ReuseLibType)[keyof typeof ReuseLibType];
  *
  * Replaces: findAllProjectRoots from @sap/ux-project-access
  *
+ * @param fs - mem-fs editor
  * @param paths - Array of root paths to search
  * @param sapuxRequired - If true, only return projects with sapux in dependencies
  * @returns Array of project root paths
  */
-export declare function findAllProjectRoots(paths: string[], sapuxRequired?: boolean): Promise<string[]>;
+export declare function findAllProjectRoots(fs: Editor, paths: string[], sapuxRequired?: boolean): Promise<string[]>;
 /**
  * Reuse library result structure
  * Matches @sap/ux-project-access getReuseLibs return type
@@ -44,10 +46,11 @@ export interface ReuseLibResult {
  * Searches for UI5 libraries and components by finding manifest.json files
  * with "sap.app.type": "library" or "component"
  *
+ * @param fs - mem-fs editor
  * @param workspaceFolders - Array of workspace folders to search
  * @returns Array of reuse library information
  */
-export declare function getReuseLibs(workspaceFolders: readonly ProjectFolder[]): Promise<ReuseLibResult[]>;
+export declare function getReuseLibs(fs: Editor, workspaceFolders: readonly ProjectFolder[]): Promise<ReuseLibResult[]>;
 /**
  * Find all files matching a pattern in a directory
  *

package/dist/utils/file-discovery.js

@@ -22,11 +22,12 @@ export const ReuseLibType = {
  *
  * Replaces: findAllProjectRoots from @sap/ux-project-access
  *
+ * @param fs - mem-fs editor
  * @param paths - Array of root paths to search
  * @param sapuxRequired - If true, only return projects with sapux in dependencies
  * @returns Array of project root paths
  */
-export async function findAllProjectRoots(paths, sapuxRequired = false) {
+export async function findAllProjectRoots(fs, paths, sapuxRequired = false) {
     const roots = [];
     const ignorePatterns = ['**/node_modules/**', '**/dist/**', '**/.git/**'];
     // Process all search paths in parallel for better performance
@@ -46,7 +47,7 @@ export async function findAllProjectRoots(paths, sapuxRequired = false) {
                 const dir = normalize(dirname(pkgPath));
                 if (sapuxRequired) {
                     try {
-                        const pkg = await readJSON(pkgPath);
+                        const pkg = await readJSON(fs, pkgPath);
                         // Check for SAP UX / Fiori Tools markers:
                         // 1. "sapux": true property (Fiori Tools marker)
                         // 2. Dependencies starting with @sap-ux/ or @sap/ux- (Fiori Tools packages)
@@ -143,10 +144,11 @@ async function findLibraryProjectRoot(manifestPath, workspaceBoundary) {
  * Searches for UI5 libraries and components by finding manifest.json files
  * with "sap.app.type": "library" or "component"
  *
+ * @param fs - mem-fs editor
  * @param workspaceFolders - Array of workspace folders to search
  * @returns Array of reuse library information
  */
-export async function getReuseLibs(workspaceFolders) {
+export async function getReuseLibs(fs, workspaceFolders) {
     // Process all workspace folders in parallel
     const folderResults = await Promise.all(workspaceFolders.map(async (folder) => {
         try {
@@ -163,7 +165,7 @@ export async function getReuseLibs(workspaceFolders) {
                 // so paths match what callers build with path.join (fails on Windows otherwise).
                 const manifestPath = normalize(rawManifestPath);
                 try {
-                    const manifest = await readJSON(manifestPath);
+                    const manifest = await readJSON(fs, manifestPath);
                     const sapApp = manifest?.['sap.app'];
                     const type = sapApp?.type;
                     // Only include libraries and components

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

@@ -25,12 +25,22 @@ export declare const escapeSingleQuotes: (s: string) => string;
  * @param s
  */
 export declare const escapeDoubleQuotes: (s: string) => string;
+export declare function doesPropertyExist(obj: unknown, fieldName: string): boolean;
 /**
- * Check if directory exists
- * Uses editorHasPath to avoid fs.exists() side effect of staging paths
+ * Check if directory exists.
+ * Uses editorHasPath to avoid fs.exists() side effect of staging paths, then falls back
+ * to the real filesystem for directories that are not yet staged in mem-fs.
  *
- * @param directoryOrFs - Directory path, or Editor instance
- * @param directory - Directory path (if first param is Editor)
+ * @param directory - Directory path
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export declare function doesDirectoryExists(directoryOrFs: string | Editor, directory?: string): boolean;
+export declare function doesDirectoryExists(directory: string, fsEditor?: Editor): boolean;
+/**
+ * Create directory if it doesn't exist
+ *
+ * @param directory - Directory path to create
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
+ * @returns True if directory was created, false if it already existed
+ */
+export declare function createDirectory(directory: string, fsEditor?: Editor): Promise<boolean>;
 //# sourceMappingURL=file-system-utils.d.ts.map

package/dist/utils/file-system-utils.js

@@ -1,4 +1,6 @@
-import { editorHasPath, getEditor } from './fs-adapter.js';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { editorHasPath, createMemFsEditor } from './fs-adapter.js';
 /**
  * Normalize path separators to forward slashes for cross-platform compatibility
  * mem-fs and many tools expect forward slashes regardless of OS
@@ -24,18 +26,39 @@ export const escapeSingleQuotes = (s) => s.replaceAll('\\', String.raw `\\`).rep
  *
  * @param s
  */
-export const escapeDoubleQuotes = (s) => s.replaceAll('\\', String.raw `\\`).replaceAll('"', String.raw `\"`);
+export const escapeDoubleQuotes = (s) => s.replaceAll('"', String.raw `\"`);
+export function doesPropertyExist(obj, fieldName) {
+    return Object.hasOwn(obj, fieldName);
+}
+/**
+ * Check if directory exists.
+ * Uses editorHasPath to avoid fs.exists() side effect of staging paths, then falls back
+ * to the real filesystem for directories that are not yet staged in mem-fs.
+ *
+ * @param directory - Directory path
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
+ */
+export function doesDirectoryExists(directory, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
+    if (editorHasPath(fs, directory)) {
+        return true;
+    }
+    return existsSync(directory);
+}
 /**
- * Check if directory exists
- * Uses editorHasPath to avoid fs.exists() side effect of staging paths
+ * Create directory if it doesn't exist
  *
- * @param directoryOrFs - Directory path, or Editor instance
- * @param directory - Directory path (if first param is Editor)
+ * @param directory - Directory path to create
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
+ * @returns True if directory was created, false if it already existed
  */
-export function doesDirectoryExists(directoryOrFs, directory) {
-    const fs = getEditor(directoryOrFs);
-    const dir = typeof directoryOrFs === 'string' ? directoryOrFs : directory;
-    // Use editorHasPath instead of fs.exists() to avoid side effect of staging paths
-    return editorHasPath(fs, dir);
+export async function createDirectory(directory, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
+    let isCreated = false;
+    if (!doesDirectoryExists(directory, fs)) {
+        await mkdir(directory, { recursive: true });
+        isCreated = true;
+    }
+    return isCreated;
 }
 //# sourceMappingURL=file-system-utils.js.map

package/dist/utils/fs-adapter.d.ts

@@ -1,33 +1,17 @@
 /**
- * Mem-fs editor utilities with context-based management
+ * Mem-fs editor utilities.
  *
- * Provides thread-safe, per-invocation Editor instances for the migration writer.
- * Uses AsyncLocalStorage to track the current migration's editor without requiring
- * it to be passed through every function call.
+ * Provides per-invocation Editor instances for the migration writer. The editor is
+ * threaded explicitly through the call tree (as in the other open-ux-tools writers),
+ * so there is no implicit/global context here.
  */
 import type { Editor } from 'mem-fs-editor';
-/**
- * Get editor from context, parameter, or create a new one.
- * Priority: explicit parameter > context > new instance
- *
- * @param editorOrPath - Editor instance or a path string
- */
-export declare function getEditor(editorOrPath: string | Editor): Editor;
 /**
  * Create a new mem-fs editor instance
  *
  * @returns New mem-fs editor instance
  */
 export declare function createMemFsEditor(): Editor;
-/**
- * Run a function with an editor in context
- * The editor will be available to all functions called within the callback
- *
- * @param editor - Editor instance to use
- * @param callback - Function to run with the editor in context
- * @returns Result of the callback
- */
-export declare function runWithEditor<T>(editor: Editor, callback: () => T | Promise<T>): T | Promise<T>;
 /**
  * Load every file under a project folder into the mem-fs store.
  *
@@ -39,56 +23,14 @@ export declare function runWithEditor<T>(editor: Editor, callback: () => T | Pro
  * @param projectRoot - Absolute path to the project folder to load
  */
 export declare function loadProjectIntoEditor(editor: Editor, projectRoot: string): Promise<void>;
-/**
- * Get the current editor from context
- *
- * @returns Current editor or undefined if not in a migration context
- */
-export declare function getCurrentEditor(): Editor | undefined;
-/**
- * Check if an editor is available in the current context
- *
- * @returns True if editor is available
- */
-export declare function isMemFsEnabled(): boolean;
 /**
  * Check whether an editor contains a file or a directory represented by staged files.
  *
- * WARNING: Do NOT use editor.exists() as it has a side effect of staging the file!
+ * WARNING: Do NOT use editor.exists() for directories as it only reports files.
  *
  * @param editor - Mem-fs editor to inspect
  * @param path - Absolute file or directory path
  * @returns True when the path or one of its children is staged in mem-fs
  */
 export declare function editorHasPath(editor: Editor, path: string): boolean;
-/**
- * Check if a file/directory exists (async).
- *
- * When an editor is in context, the migration tree is already loaded into mem-fs, so a staged
- * path is authoritative. A real-filesystem check is still used as a fallback so files that were
- * never loaded into mem-fs are not reported missing (and therefore not silently overwritten).
- *
- * @param path - Path to check
- * @returns True if staged in mem-fs OR present on the real filesystem
- */
-export declare function exists(path: string): Promise<boolean>;
-/**
- * Copy file using mem-fs or real filesystem
- *
- * @param src - Source path
- * @param dest - Destination path
- */
-export declare function copyFile(src: string, dest: string): void;
-/**
- * Delete file using mem-fs or real filesystem
- *
- * @param path - Path to delete
- */
-export declare function deleteFile(path: string): void;
-/**
- * Create directory (no-op in mem-fs, directories created implicitly)
- *
- * @param _path - Directory path
- */
-export declare function mkdir(_path: string): void;
 //# sourceMappingURL=fs-adapter.d.ts.map

package/dist/utils/fs-adapter.js

@@ -1,29 +1,7 @@
 import { create as createMemFs } from 'mem-fs';
 import { create as createEditor } from 'mem-fs-editor';
-import { access } from 'node:fs/promises';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import fastGlob from 'fast-glob';
 import { normalizePath } from './file-system-utils.js';
-/**
- * AsyncLocalStorage for tracking the current migration's editor
- */
-const editorContext = new AsyncLocalStorage();
-/**
- * Get editor from context, parameter, or create a new one.
- * Priority: explicit parameter > context > new instance
- *
- * @param editorOrPath - Editor instance or a path string
- */
-export function getEditor(editorOrPath) {
-    if (typeof editorOrPath !== 'string') {
-        return editorOrPath;
-    }
-    const contextEditor = getCurrentEditor();
-    if (contextEditor) {
-        return contextEditor;
-    }
-    return createMemFsEditor();
-}
 /**
  * Create a new mem-fs editor instance
  *
@@ -33,17 +11,6 @@ export function createMemFsEditor() {
     const store = createMemFs();
     return createEditor(store);
 }
-/**
- * Run a function with an editor in context
- * The editor will be available to all functions called within the callback
- *
- * @param editor - Editor instance to use
- * @param callback - Function to run with the editor in context
- * @returns Result of the callback
- */
-export function runWithEditor(editor, callback) {
-    return editorContext.run(editor, callback);
-}
 /**
  * Load every file under a project folder into the mem-fs store.
  *
@@ -70,26 +37,10 @@ export async function loadProjectIntoEditor(editor, projectRoot) {
         store.get(file);
     }
 }
-/**
- * Get the current editor from context
- *
- * @returns Current editor or undefined if not in a migration context
- */
-export function getCurrentEditor() {
-    return editorContext.getStore();
-}
-/**
- * Check if an editor is available in the current context
- *
- * @returns True if editor is available
- */
-export function isMemFsEnabled() {
-    return getCurrentEditor() !== undefined;
-}
 /**
  * Check whether an editor contains a file or a directory represented by staged files.
  *
- * WARNING: Do NOT use editor.exists() as it has a side effect of staging the file!
+ * WARNING: Do NOT use editor.exists() for directories as it only reports files.
  *
  * @param editor - Mem-fs editor to inspect
  * @param path - Absolute file or directory path
@@ -105,6 +56,11 @@ export function editorHasPath(editor, path) {
         if (file.state === 'deleted') {
             return;
         }
+        // Ignore entries with no content: a missing path that was only probed via store.get()
+        // (e.g. by fs.exists/fs.read) is cached with contents === null and must not count as present.
+        if (file.contents === null) {
+            return;
+        }
         // Normalize file path as well for comparison
         const normalizedFilePath = normalizePath(file.path);
         // Check exact match OR files under this directory
@@ -114,65 +70,4 @@ export function editorHasPath(editor, path) {
     });
     return found;
 }
-/**
- * Check if a file/directory exists (async).
- *
- * When an editor is in context, the migration tree is already loaded into mem-fs, so a staged
- * path is authoritative. A real-filesystem check is still used as a fallback so files that were
- * never loaded into mem-fs are not reported missing (and therefore not silently overwritten).
- *
- * @param path - Path to check
- * @returns True if staged in mem-fs OR present on the real filesystem
- */
-export async function exists(path) {
-    const editor = getCurrentEditor();
-    if (editor && editorHasPath(editor, path)) {
-        return true;
-    }
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Copy file using mem-fs or real filesystem
- *
- * @param src - Source path
- * @param dest - Destination path
- */
-export function copyFile(src, dest) {
-    const editor = getCurrentEditor();
-    if (editor) {
-        editor.copy(src, dest);
-    }
-    else {
-        throw new Error('Editor not available. Call runWithEditor() to set up the migration context.');
-    }
-}
-/**
- * Delete file using mem-fs or real filesystem
- *
- * @param path - Path to delete
- */
-export function deleteFile(path) {
-    const editor = getCurrentEditor();
-    if (editor) {
-        editor.delete(path);
-    }
-    else {
-        throw new Error('Editor not available. Call runWithEditor() to set up the migration context.');
-    }
-}
-/**
- * Create directory (no-op in mem-fs, directories created implicitly)
- *
- * @param _path - Directory path
- */
-export function mkdir(_path) {
-    // mem-fs handles directories implicitly when writing files
-    // No explicit mkdir needed
-}
 //# sourceMappingURL=fs-adapter.js.map

package/dist/utils/manifest-and-version-utils.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '../project-spec-types.js';
 import { FioriElementsVersion } from '../project-spec-types.js';
 import type { ImportProjectInfo } from '../types.js';
@@ -19,8 +20,9 @@ export declare function checkManifestUI5Version(manifestUI5Version: string): str
  * @param rootPath
  * @param webappPath
  * @param uiAdaptation
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export declare function readManifest(rootPath: string, webappPath: string, uiAdaptation?: any): Promise<Manifest | undefined>;
+export declare function readManifest(rootPath: string, webappPath: string, uiAdaptation?: any, fsEditor?: Editor): Promise<Manifest | undefined>;
 /**
  * Determine if we are dealing with a SAP Freestyle application
  *

package/dist/utils/manifest-and-version-utils.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { FileName, FioriElementsVersion } from '../project-spec-types.js';
 import { fileExists, readJSON } from './file-access.js';
+import { createMemFsEditor } from './fs-adapter.js';
 import semver from 'semver';
 import { distVar } from './constants.js';
 import { stripSpaces } from './file-system-utils.js';
@@ -38,12 +39,14 @@ export function checkManifestUI5Version(manifestUI5Version) {
  * @param rootPath
  * @param webappPath
  * @param uiAdaptation
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export async function readManifest(rootPath, webappPath, uiAdaptation) {
+export async function readManifest(rootPath, webappPath, uiAdaptation, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
     const manifestPath = join(rootPath, webappPath, FileName.Manifest);
     let manifestJSON;
-    if (uiAdaptation === undefined && (await fileExists(manifestPath))) {
-        manifestJSON = await readJSON(manifestPath);
+    if (uiAdaptation === undefined && fileExists(fs, manifestPath)) {
+        manifestJSON = await readJSON(fs, manifestPath);
     }
     return manifestJSON;
 }