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

package/dist/utils/migration-utils.d.ts

@@ -1,4 +1,5 @@
 import type { Data } from 'ejs';
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest, SapAppSourceTemplate } from '../project-spec-types.js';
 import type { TemplateProperties, SapUxLayer } from '../types.js';
 /**
@@ -27,13 +28,14 @@ export declare function determineMessage(error: Error, filename?: string, useMes
 /**
  * Generate template file using EJS and template utilities
  *
+ * @param fs - mem-fs editor
  * @param templateData
  * @param projectRoot
  * @param templateRoot
  * @param templateName
  * @param templateProps
  */
-export declare function generateTemplate(templateData: Data, projectRoot: string, templateRoot: string, templateName: string, templateProps: TemplateProperties): Promise<void>;
+export declare function generateTemplate(fs: Editor, templateData: Data, projectRoot: string, templateRoot: string, templateName: string, templateProps: TemplateProperties): Promise<void>;
 /**
  * Creates the sourceTemplate manifest.json entry.
  * This will respect the existing values if they are defined and not an empty string

package/dist/utils/migration-utils.js

@@ -67,13 +67,14 @@ export function determineMessage(error, filename, useMessage) {
 /**
  * Generate template file using EJS and template utilities
  *
+ * @param fs - mem-fs editor
  * @param templateData
  * @param projectRoot
  * @param templateRoot
  * @param templateName
  * @param templateProps
  */
-export async function generateTemplate(templateData, projectRoot, templateRoot, templateName, templateProps) {
+export async function generateTemplate(fs, templateData, projectRoot, templateRoot, templateName, templateProps) {
     // Import template utilities
     const { resolveTemplatePaths, resolveTemplateData, renderTemplate, applyFileSpecificHandlers } = await import('./template/index.js');
     // 1. Resolve paths
@@ -82,12 +83,12 @@ export async function generateTemplate(templateData, projectRoot, templateRoot,
     const resolvedData = resolveTemplateData(templateData, templateProps);
     // 3. Render template (mem-fs handles directory creation implicitly)
     const { isRendered = true, opts = {} } = templateProps;
-    let content = renderTemplate(templateRoot, fullTemplateName, resolvedData, opts, isRendered);
+    let content = renderTemplate(fs, templateRoot, fullTemplateName, resolvedData, opts, isRendered);
     // 4. Apply file-specific handlers
-    content = await applyFileSpecificHandlers(templateName, content, projectRoot, targetFile, templateData);
+    content = await applyFileSpecificHandlers(fs, templateName, content, projectRoot, targetFile, templateData);
     // 5. Write file (mem-fs handles directory creation implicitly)
     // Do not catch - let errors propagate to caller for proper handling
-    writeFile(targetFile, content);
+    writeFile(fs, targetFile, content);
 }
 /**
  * Creates the sourceTemplate manifest.json entry.

package/dist/utils/project-access-adapters.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Find all manifest.json files in given workspace roots
  *
@@ -12,9 +13,10 @@ export declare function findAllManifest(roots: string[]): Promise<string[]>;
  *
  * Uses modern @sap-ux/project-access hasDependency
  *
+ * @param fs - mem-fs editor
  * @param projectPath - Path to project root
  * @param dependencyName - Dependency name to check
  * @returns true if project has the dependency
  */
-export declare function isFioriToolsProject(projectPath: string, dependencyName: string): Promise<boolean>;
+export declare function isFioriToolsProject(fs: Editor, projectPath: string, dependencyName: string): Promise<boolean>;
 //# sourceMappingURL=project-access-adapters.d.ts.map

package/dist/utils/project-access-adapters.js

@@ -40,14 +40,15 @@ export async function findAllManifest(roots) {
  *
  * Uses modern @sap-ux/project-access hasDependency
  *
+ * @param fs - mem-fs editor
  * @param projectPath - Path to project root
  * @param dependencyName - Dependency name to check
  * @returns true if project has the dependency
  */
-export async function isFioriToolsProject(projectPath, dependencyName) {
+export async function isFioriToolsProject(fs, projectPath, dependencyName) {
     try {
         const packageJsonPath = join(projectPath, 'package.json');
-        const packageJson = await readJSON(packageJsonPath);
+        const packageJson = await readJSON(fs, packageJsonPath);
         return hasDependency(packageJson, dependencyName);
     }
     catch {

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

@@ -1,16 +1,20 @@
+import type { Editor } from 'mem-fs-editor';
 import type { ProjectAppPath, ProjectFolder } from '../types.js';
 /**
  * Find all maven project(s) by locating pom.xml in the VS code workspace(s)
  *
+ * @param fs
  * @param wsFolders
  */
-export declare function findAllWebIDEProjectFolders(wsFolders: readonly ProjectFolder[] | string[]): Promise<string[]>;
+export declare function findAllWebIDEProjectFolders(fs: Editor, wsFolders: readonly ProjectFolder[] | string[]): Promise<string[]>;
 /**
  * Get Pom project paths as labels for use in project picker
+ * Uses a broader scan (including src/ dirs) to find all WebIDE projects.
  *
  * @param workspaceRoots
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export declare function getWebIDEProjectPathsAsLabels(workspaceRoots: ProjectFolder[]): Promise<ProjectAppPath[]>;
+export declare function getWebIDEProjectPathsAsLabels(workspaceRoots: ProjectFolder[], fsEditor?: Editor): Promise<ProjectAppPath[]>;
 /**
  * Find projects by manifest.json in workspace roots
  *

package/dist/utils/project-discovery.js

@@ -1,14 +1,16 @@
 import { basename, dirname, join, sep } from 'node:path';
 import fg from 'fast-glob';
+import { createMemFsEditor } from './fs-adapter.js';
 import { DirName, FileName } from '../project-spec-types.js';
 import { isFioriToolsProject, findAllManifest } from './project-access-adapters.js';
 import { isProjectFolderArray } from '../types/project-folder.js';
 /**
  * Find all maven project(s) by locating pom.xml in the VS code workspace(s)
  *
+ * @param fs
  * @param wsFolders
  */
-export async function findAllWebIDEProjectFolders(wsFolders) {
+export async function findAllWebIDEProjectFolders(fs, wsFolders) {
     let wsRoots;
     if (isProjectFolderArray(wsFolders)) {
         wsRoots = wsFolders.filter((folder) => folder.uri.scheme === 'file').map((folder) => folder.uri.fsPath);
@@ -16,10 +18,10 @@ export async function findAllWebIDEProjectFolders(wsFolders) {
     else {
         wsRoots = wsFolders || [];
     }
-    // Process all workspace roots in parallel
+    // Process all workspace roots in parallel, skipping src/ to avoid nested test suites
     const projectArrays = await Promise.all(wsRoots.map(async (root) => {
         try {
-            return await findWebIDEProject(root);
+            return await findWebIDEProject(fs, root, true);
         }
         catch {
             // Continue scanning other roots even if one fails
@@ -32,23 +34,28 @@ export async function findAllWebIDEProjectFolders(wsFolders) {
 /**
  * Find all maven project(s) by locating pom.xml in the VS code workspace root
  *
+ * @param fs
  * @param wsRoot
+ * @param skipSrcDirs - If true, skip scanning src/ directories (used for getProjectRoots)
  * @returns Array of project paths
  */
-async function findWebIDEProject(wsRoot) {
+async function findWebIDEProject(fs, wsRoot, skipSrcDirs = true) {
     const projects = [];
+    const ignore = [
+        '.git',
+        'node_modules',
+        '**/node_modules/**',
+        'dist',
+        '**/dist/**',
+        `**/${DirName.Webapp}/**`,
+        '**/Web/MDKModule/**'
+    ];
+    if (skipSrcDirs) {
+        ignore.push(`**/${DirName.Sapux}/**`); // GH #14290 — skip src/ to avoid nested test suites
+    }
     const entries = await fg([`**/${FileName.Pom}`, `**/${FileName.NeoApp}`], {
         cwd: wsRoot,
-        ignore: [
-            '.git',
-            'node_modules',
-            '**/node_modules/**',
-            'dist',
-            '**/dist/**',
-            `**/${DirName.Sapux}/**`,
-            `**/${DirName.Webapp}/**`,
-            '**/Web/MDKModule/**'
-        ] // GH #14290
+        ignore
     });
     // Process all entries in parallel
     const results = await Promise.all(entries.map(async (entry) => {
@@ -56,8 +63,8 @@ async function findWebIDEProject(wsRoot) {
         const dir = dirname(file);
         // Check for neo-app.json or pom.xml file present
         // Check both tooling packages (await in series is intentional - short-circuit on first match)
-        const fioriToolsProject = (await isFioriToolsProject(dir, '@sap-ux/ui5-tooling')) ||
-            (await isFioriToolsProject(dir, '@sap/ux-ui5-tooling'));
+        const fioriToolsProject = (await isFioriToolsProject(fs, dir, '@sap-ux/ui5-tooling')) ||
+            (await isFioriToolsProject(fs, dir, '@sap/ux-ui5-tooling'));
         return !fioriToolsProject ? dir : null;
     }));
     // Filter out nulls and duplicates
@@ -67,12 +74,31 @@ async function findWebIDEProject(wsRoot) {
 }
 /**
  * Get Pom project paths as labels for use in project picker
+ * Uses a broader scan (including src/ dirs) to find all WebIDE projects.
  *
  * @param workspaceRoots
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export async function getWebIDEProjectPathsAsLabels(workspaceRoots) {
+export async function getWebIDEProjectPathsAsLabels(workspaceRoots, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
     const result = [];
-    let roots = await findAllWebIDEProjectFolders(workspaceRoots);
+    let wsRoots;
+    if (isProjectFolderArray(workspaceRoots)) {
+        wsRoots = workspaceRoots.filter((folder) => folder.uri.scheme === 'file').map((folder) => folder.uri.fsPath);
+    }
+    else {
+        wsRoots = workspaceRoots || [];
+    }
+    // Use broader scan (skipSrcDirs=false) to also find nested WebIDE projects in src/
+    const projectArrays = await Promise.all(wsRoots.map(async (root) => {
+        try {
+            return await findWebIDEProject(fs, root, false);
+        }
+        catch {
+            return [];
+        }
+    }));
+    let roots = projectArrays.flat();
     if (workspaceRoots.length > 1) {
         roots = [...new Set(roots)];
     }

package/dist/utils/project-readers/adaptation-project-utils.d.ts

@@ -2,19 +2,22 @@
  * Utilities for detecting and processing adaptation projects
  * Handles both legacy WebIDE and Fiori Tools adaptation projects
  */
+import type { Editor } from 'mem-fs-editor';
 /**
  * Check if project is a migratable adaptation project
  * Checks both legacy WebIDE (.che/project.json) and Fiori Tools (.adp/config.json) formats
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Adaptation project configuration or undefined
  */
-export declare function checkMigratableAdaptationProject(projectRoot: string): Promise<any>;
+export declare function checkMigratableAdaptationProject(fs: Editor, projectRoot: string): Promise<any>;
 /**
  * Check if project is a Fiori Tools adaptation project
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns True if .adp/config.json exists
  */
-export declare function isFioriToolsAdaptationProject(projectRoot: string): Promise<boolean>;
+export declare function isFioriToolsAdaptationProject(fs: Editor, projectRoot: string): boolean;
 //# sourceMappingURL=adaptation-project-utils.d.ts.map

package/dist/utils/project-readers/adaptation-project-utils.js

@@ -9,28 +9,29 @@ import { sapWattCommonSetting } from '../../types.js';
  * Check if project is a migratable adaptation project
  * Checks both legacy WebIDE (.che/project.json) and Fiori Tools (.adp/config.json) formats
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Adaptation project configuration or undefined
  */
-export async function checkMigratableAdaptationProject(projectRoot) {
+export async function checkMigratableAdaptationProject(fs, projectRoot) {
     let adaptationProject;
     // Check for legacy WebIDE adaptation project settings
-    adaptationProject = await checkCheProjectSettings(projectRoot);
+    adaptationProject = await checkCheProjectSettings(fs, projectRoot);
     // Check for Fiori Tools adaptation project
-    const adpConfig = await checkFioriToolsAdaptation(projectRoot);
+    const adpConfig = await checkFioriToolsAdaptation(fs, projectRoot);
     if (adpConfig) {
         adaptationProject = adpConfig;
     }
     // Legacy projects may contain only manifest.appdescr_variant without a project settings file.
     if (!adaptationProject) {
-        const reference = await readManifestReference(projectRoot);
+        const reference = await readManifestReference(fs, projectRoot);
         if (reference) {
             adaptationProject = { appvariant: reference, reference };
         }
     }
     // Read manifest.appdescr_variant reference if available
     if (adaptationProject) {
-        const ref = await readManifestReference(projectRoot);
+        const ref = await readManifestReference(fs, projectRoot);
         if (ref !== undefined) {
             adaptationProject.reference = ref;
         }
@@ -40,14 +41,15 @@ export async function checkMigratableAdaptationProject(projectRoot) {
 /**
  * Check for legacy WebIDE adaptation project settings in .che/project.json
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Adaptation project settings or undefined
  */
-async function checkCheProjectSettings(projectRoot) {
+async function checkCheProjectSettings(fs, projectRoot) {
     try {
         const cheProjectJsonPath = join(projectRoot, '.che', 'project.json');
-        if (await fileExists(cheProjectJsonPath)) {
-            const projectJson = await readJSON(cheProjectJsonPath);
+        if (fileExists(fs, cheProjectJsonPath)) {
+            const projectJson = await readJSON(fs, cheProjectJsonPath);
             if (projectJson?.attributes?.[sapWattCommonSetting]) {
                 try {
                     const settings = JSON.parse(projectJson.attributes[sapWattCommonSetting]?.[0]);
@@ -69,13 +71,14 @@ async function checkCheProjectSettings(projectRoot) {
 /**
  * Check for Fiori Tools adaptation project (.adp/config.json)
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Adaptation project config with isAdp flag or undefined
  */
-async function checkFioriToolsAdaptation(projectRoot) {
+async function checkFioriToolsAdaptation(fs, projectRoot) {
     try {
-        if (await isFioriToolsAdaptationProject(projectRoot)) {
-            const config = await readJSON(join(projectRoot, '.adp', 'config.json'));
+        if (isFioriToolsAdaptationProject(fs, projectRoot)) {
+            const config = await readJSON(fs, join(projectRoot, '.adp', 'config.json'));
             if (config) {
                 config.isAdp = true;
                 return config;
@@ -90,14 +93,15 @@ async function checkFioriToolsAdaptation(projectRoot) {
 /**
  * Read reference from manifest.appdescr_variant
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Reference string or undefined
  */
-async function readManifestReference(projectRoot) {
+async function readManifestReference(fs, projectRoot) {
     try {
         const manifestAppdescrPath = join(projectRoot, 'webapp', 'manifest.appdescr_variant');
-        if (await fileExists(manifestAppdescrPath)) {
-            const manifestAppdescr = await readJSON(manifestAppdescrPath);
+        if (fileExists(fs, manifestAppdescrPath)) {
+            const manifestAppdescr = await readJSON(fs, manifestAppdescrPath);
             return manifestAppdescr?.reference ?? '';
         }
     }
@@ -109,11 +113,12 @@ async function readManifestReference(projectRoot) {
 /**
  * Check if project is a Fiori Tools adaptation project
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns True if .adp/config.json exists
  */
-export async function isFioriToolsAdaptationProject(projectRoot) {
+export function isFioriToolsAdaptationProject(fs, projectRoot) {
     const adpConfigJsonPath = join(projectRoot, '.adp', 'config.json');
-    return fileExists(adpConfigJsonPath);
+    return fileExists(fs, adpConfigJsonPath);
 }
 //# sourceMappingURL=adaptation-project-utils.js.map

package/dist/utils/project-readers/backend-utils.d.ts

@@ -2,6 +2,7 @@
  * Utilities for backend/destination configuration
  * Handles neo-app.json and destination settings
  */
+import type { Editor } from 'mem-fs-editor';
 import type { NeoappDestination } from '../../types.js';
 /**
  * Get client number from destination name if it ends with 3 digits
@@ -26,11 +27,12 @@ export declare function getNeoAppData(neoAppJson: any, destination: string, isUi
 /**
  * Read destination info from neo-app.json file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @param destinationIn - Initial destination (may be empty)
  * @returns Destination info or undefined if no neo-app.json found
  */
-export declare function getDestinationFromNeoApp(projectRoot: string, destinationIn: string): Promise<{
+export declare function getDestinationFromNeoApp(fs: Editor, projectRoot: string, destinationIn: string): Promise<{
     destination: string;
     neoAppUI5Version?: string;
     neoappDestinations?: NeoappDestination[];

package/dist/utils/project-readers/backend-utils.js

@@ -72,15 +72,16 @@ export function getNeoAppData(neoAppJson, destination, isUiAdaptation = false) {
 /**
  * Read destination info from neo-app.json file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @param destinationIn - Initial destination (may be empty)
  * @returns Destination info or undefined if no neo-app.json found
  */
-export async function getDestinationFromNeoApp(projectRoot, destinationIn) {
+export async function getDestinationFromNeoApp(fs, projectRoot, destinationIn) {
     try {
         const neoAppJsonPath = join(projectRoot, TemplateFileName.NeoApp);
-        if (await fileExists(neoAppJsonPath)) {
-            const neoAppJson = await readJSON(neoAppJsonPath);
+        if (fileExists(fs, neoAppJsonPath)) {
+            const neoAppJson = await readJSON(fs, neoAppJsonPath);
             if (neoAppJson?.routes) {
                 const { destination, neoAppUI5Version, neoappDestinations } = getNeoAppData(neoAppJson, destinationIn);
                 return { destination, neoAppUI5Version, neoappDestinations };

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

@@ -2,22 +2,25 @@
  * Utilities for detecting and processing extension projects
  * Handles both legacy WebIDE and new format extension projects
  */
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '../../project-spec-types.js';
 /**
  * Read project extension settings from configuration files
  * Checks both .che/project.json (WebIDE) and .project.json (legacy) formats
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Extension settings or undefined
  */
-export declare function readProjectExtensionSettings(projectRoot: string): Promise<unknown>;
+export declare function readProjectExtensionSettings(fs: Editor, projectRoot: string): Promise<unknown>;
 /**
  * Check if project is an extension project
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns True if extension settings found
  */
-export declare function checkIfProjectExtension(projectRoot: string): Promise<boolean>;
+export declare function checkIfProjectExtension(fs: Editor, projectRoot: string): Promise<boolean>;
 /**
  * Get module name for extension project
  *

package/dist/utils/project-readers/extension-project-utils.js

@@ -9,18 +9,19 @@ import { sapWattCommonSetting } from '../../types.js';
  * Read project extension settings from configuration files
  * Checks both .che/project.json (WebIDE) and .project.json (legacy) formats
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Extension settings or undefined
  */
-export async function readProjectExtensionSettings(projectRoot) {
+export async function readProjectExtensionSettings(fs, projectRoot) {
     try {
         // Try .che/project.json first
-        const cheSettings = await readCheProjectExtensionSettings(projectRoot);
+        const cheSettings = await readCheProjectExtensionSettings(fs, projectRoot);
         if (cheSettings) {
             return cheSettings;
         }
         // Fallback to .project.json
-        const legacySettings = await readLegacyProjectExtensionSettings(projectRoot);
+        const legacySettings = await readLegacyProjectExtensionSettings(fs, projectRoot);
         if (legacySettings) {
             return legacySettings;
         }
@@ -33,17 +34,18 @@ export async function readProjectExtensionSettings(projectRoot) {
 /**
  * Read extension settings from .che/project.json
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Extension settings or undefined
  */
-async function readCheProjectExtensionSettings(projectRoot) {
+async function readCheProjectExtensionSettings(fs, projectRoot) {
     const projectJsonPath = join(projectRoot, '.che', 'project.json');
-    const exists = await fileExists(projectJsonPath);
+    const exists = fileExists(fs, projectJsonPath);
     if (!exists) {
         return undefined;
     }
     try {
-        const projectJson = await readJSON(projectJsonPath);
+        const projectJson = await readJSON(fs, projectJsonPath);
         if (projectJson?.attributes?.[sapWattCommonSetting]?.[0]) {
             const settings = JSON.parse(projectJson.attributes[sapWattCommonSetting][0]);
             return settings?.extensibility;
@@ -57,16 +59,17 @@ async function readCheProjectExtensionSettings(projectRoot) {
 /**
  * Read extension settings from .project.json (legacy format)
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Extension settings or undefined
  */
-async function readLegacyProjectExtensionSettings(projectRoot) {
+async function readLegacyProjectExtensionSettings(fs, projectRoot) {
     const projectJsonPath = join(projectRoot, '.project.json');
-    if (!(await fileExists(projectJsonPath))) {
+    if (!fileExists(fs, projectJsonPath)) {
         return undefined;
     }
     try {
-        const projectJson = await readJSON(projectJsonPath);
+        const projectJson = await readJSON(fs, projectJsonPath);
         return projectJson?.extensibility;
     }
     catch (error) {
@@ -77,11 +80,12 @@ async function readLegacyProjectExtensionSettings(projectRoot) {
 /**
  * Check if project is an extension project
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns True if extension settings found
  */
-export async function checkIfProjectExtension(projectRoot) {
-    const extensionProject = await readProjectExtensionSettings(projectRoot);
+export async function checkIfProjectExtension(fs, projectRoot) {
+    const extensionProject = await readProjectExtensionSettings(fs, projectRoot);
     return !!extensionProject;
 }
 /**

package/dist/utils/project-readers/manifest-reader.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '../../project-spec-types.js';
 /**
  * Get manifest.json file path
@@ -9,8 +10,9 @@ export declare function getManifestPath(projectRoot: string, webappPath: string)
 /**
  * Get manifest.json content
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  * @param webappPath
  */
-export declare function getManifestJson(projectRoot: string, webappPath: string): Promise<Manifest>;
+export declare function getManifestJson(fs: Editor, projectRoot: string, webappPath: string): Manifest;
 //# sourceMappingURL=manifest-reader.d.ts.map

package/dist/utils/project-readers/manifest-reader.js

@@ -16,11 +16,12 @@ export function getManifestPath(projectRoot, webappPath) {
 /**
  * Get manifest.json content
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  * @param webappPath
  */
-export async function getManifestJson(projectRoot, webappPath) {
+export function getManifestJson(fs, projectRoot, webappPath) {
     const manifestPath = getManifestPath(projectRoot, webappPath);
-    return readJSON(manifestPath);
+    return readJSON(fs, manifestPath);
 }
 //# sourceMappingURL=manifest-reader.js.map

package/dist/utils/project-readers/manifest-utils.d.ts

@@ -2,6 +2,7 @@
  * Utilities for manifest.json parsing and analysis
  * Handles FE version detection, floor plan determination, and semantic objects
  */
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '../../project-spec-types.js';
 import { FioriElementsVersion } from '../../project-spec-types.js';
 /**
@@ -21,10 +22,11 @@ export declare function getSemanticObjectAction(manifest: Manifest): string | un
 /**
  * Extract FLP intent from HTML file (flpSandbox.html or similar)
  *
+ * @param fs - mem-fs editor
  * @param htmlFilePath - Path to HTML file
  * @returns FLP intent string or undefined
  */
-export declare function getFlpIntentFromHtml(htmlFilePath: string): Promise<string | undefined>;
+export declare function getFlpIntentFromHtml(fs: Editor, htmlFilePath: string): string | undefined;
 /**
  * Error thrown when project type is not supported for migration
  */
@@ -50,10 +52,11 @@ export declare function getMainEntity(manifest: Manifest): string;
 /**
  * Get first backend configuration from ui5.yaml
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Backend configuration object
  */
-export declare function getFirstBackend(projectRoot: string): {
+export declare function getFirstBackend(fs: Editor, projectRoot: string): {
     destination?: string;
     sapClient?: string;
     scp?: boolean;

package/dist/utils/project-readers/manifest-utils.js

@@ -4,7 +4,8 @@
  */
 import { join } from 'node:path';
 import { parse } from 'yaml';
-import { fileExists, readFile } from '../../index.js';
+import { fileExists } from '../../index.js';
+import { readFile } from '../../utils/file-access.js';
 import { FioriElementsVersion } from '../../project-spec-types.js';
 import { FLOOR_PLAN } from '../../types.js';
 import { i18nText } from '../../i18n.js';
@@ -121,15 +122,16 @@ function extractFlpIntentFromConfig(htmlContent) {
 /**
  * Extract FLP intent from HTML file (flpSandbox.html or similar)
  *
+ * @param fs - mem-fs editor
  * @param htmlFilePath - Path to HTML file
  * @returns FLP intent string or undefined
  */
-export async function getFlpIntentFromHtml(htmlFilePath) {
+export function getFlpIntentFromHtml(fs, htmlFilePath) {
     try {
-        if (!(await fileExists(htmlFilePath))) {
+        if (!fileExists(fs, htmlFilePath)) {
             return undefined;
         }
-        const htmlContent = readFile(htmlFilePath);
+        const htmlContent = readFile(fs, htmlFilePath);
         return extractFlpIntentFromConfig(htmlContent);
     }
     catch {
@@ -218,13 +220,14 @@ export function getMainEntity(manifest) {
 /**
  * Get first backend configuration from ui5.yaml
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns Backend configuration object
  */
-export function getFirstBackend(projectRoot) {
+export function getFirstBackend(fs, projectRoot) {
     let result = {};
     try {
-        const yamlJSON = parse(readFile(join(projectRoot, 'ui5.yaml')));
+        const yamlJSON = parse(readFile(fs, join(projectRoot, 'ui5.yaml')));
         const proxyMiddleware = yamlJSON?.server?.customMiddleware.filter((customMiddleware) => {
             return (customMiddleware?.name === 'fiori-tools-proxy' ||
                 customMiddleware?.name === 'ui5-middleware-simpleproxy' // used in tool-suite beta

package/dist/utils/project-readers/package-reader.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Get package.json file path
  *
@@ -7,7 +8,8 @@ export declare function getPackageJsonPath(projectRoot: string): string;
 /**
  * Get package.json content
  *
+ * @param fs - mem-fs editor
  * @param filePath
  */
-export declare function getPackageJson(filePath: string): Promise<any>;
+export declare function getPackageJson(fs: Editor, filePath: string): any;
 //# sourceMappingURL=package-reader.d.ts.map

package/dist/utils/project-readers/package-reader.js

@@ -15,9 +15,10 @@ export function getPackageJsonPath(projectRoot) {
 /**
  * Get package.json content
  *
+ * @param fs - mem-fs editor
  * @param filePath
  */
-export async function getPackageJson(filePath) {
-    return readJSON(getPackageJsonPath(filePath));
+export function getPackageJson(fs, filePath) {
+    return readJSON(fs, getPackageJsonPath(filePath));
 }
 //# sourceMappingURL=package-reader.js.map