@sap-ux/project-access 1.29.7 → 1.29.8

package/dist/library/helpers.d.ts

@@ -1,4 +1,4 @@
-import { type LibraryResults, type Manifest, type ReuseLib } from '../types';
+import { type LibraryResults, type Manifest, type ReuseLib, type LibraryXml } from '../types';
 /**
  * Returns an array of the reuse libraries found in the folders.
  *
@@ -21,14 +21,14 @@ export declare function checkDependencies(answers: ReuseLib[], reuseLibs: ReuseL
  * @param libraryPath - library path
  * @returns library description
  */
-export declare function getLibraryDesc(library: any, libraryPath: string): Promise<string>;
+export declare function getLibraryDesc(library: LibraryXml, libraryPath: string): Promise<string>;
 /**
  * Returns the library dependencies.
  *
  * @param library - library object
  * @returns array of dependencies
  */
-export declare function getLibraryDependencies(library: any): string[];
+export declare function getLibraryDependencies(library: LibraryXml): string[];
 /**
  * Returns the manifest description.
  *

package/dist/library/helpers.js

@@ -66,7 +66,7 @@ const getLibraryFromLibraryFile = async (library, libraryPath, projectRoot) => {
                 name: `${parsedFile.library.name}`,
                 path: (0, path_1.dirname)(libraryPath),
                 type: reuseType,
-                uri: parsedFile.library?.appData?.manifest?.['sap.platform.abap']?.uri || '',
+                uri: parsedFile.library?.appData?.manifest?.['sap.platform.abap']?.uri ?? '',
                 dependencies: libDeps,
                 libRoot: projectRoot,
                 description
@@ -111,7 +111,7 @@ const getReuseLibs = async (libs) => {
             ];
             for (const manifestPath of manifestPaths) {
                 const manifestFilePath = (0, path_1.join)(manifestPath, constants_2.FileName.Manifest);
-                const manifest = JSON.parse(await fs_1.promises.readFile(manifestFilePath, { encoding: 'utf8' }));
+                const manifest = await (0, file_1.readJSON)(manifestFilePath);
                 const library = await getLibraryFromManifest(manifest, manifestFilePath, reuseLibs, lib.projectRoot);
                 if (library) {
                     reuseLibs.push(library);
@@ -174,9 +174,9 @@ async function getLibraryDesc(library, libraryPath) {
     let libraryDesc = library?.library?.documentation;
     if (typeof libraryDesc === 'string' && libraryDesc.startsWith('{{')) {
         const key = libraryDesc.substring(2, libraryDesc.length - 2);
-        libraryDesc = await geti18nPropertyValue((0, path_1.join)((0, path_1.dirname)(libraryPath), library.library?.appData?.manifest?.i18n?.toString()), key);
+        libraryDesc = await geti18nPropertyValue((0, path_1.join)((0, path_1.dirname)(libraryPath), library.library?.appData?.manifest?.i18n?.toString() ?? ''), key);
     }
-    return libraryDesc.toString();
+    return libraryDesc?.toString() ?? '';
 }
 /**
  * Returns the library dependencies.
@@ -247,7 +247,8 @@ async function getManifestDesc(manifest, manifestPath) {
  */
 function getManifestDependencies(manifest) {
     const result = [];
-    Object.values(['libs', 'components']).forEach((reuseType) => {
+    const depTypes = ['libs', 'components'];
+    Object.values(depTypes).forEach((reuseType) => {
         const dependencies = manifest['sap.ui5']?.dependencies?.[reuseType];
         if (dependencies) {
             const libs = manifest?.['sap.ui5']?.dependencies?.libs;

package/dist/project/cap.js

@@ -535,11 +535,10 @@ async function getPackageNameInFolder(baseUri, relativeUri) {
 async function readPackageNameForFolder(baseUri, relativeUri) {
     let packageName = '';
     try {
-        const path = (0, path_1.normalize)(baseUri + '/' + relativeUri + '/' + 'package.json');
-        const content = await (0, file_1.readFile)(path);
-        if (content) {
-            const parsed = JSON.parse(content);
-            packageName = parsed.name;
+        const path = (0, path_1.normalize)(baseUri + '/' + relativeUri + '/' + constants_1.FileName.Package);
+        const content = await (0, file_1.readJSON)(path);
+        if (typeof content?.name === 'string') {
+            packageName = content.name;
         }
     }
     catch (e) {

package/dist/project/search.d.ts

@@ -1,5 +1,16 @@
 import type { Editor } from 'mem-fs-editor';
-import type { AllAppResults, FioriArtifactTypes, FoundFioriArtifacts, WorkspaceFolder } from '../types';
+import type { AllAppResults, CapProjectType, FioriArtifactTypes, FoundFioriArtifacts, WorkspaceFolder } from '../types';
+/**
+ * Type that is used locally only to keep list of found files with cache of the
+ * content in order to avoid multiple file reads. It also caches result of call
+ * getCapProjectType() this is expensive.
+ */
+type FileMapAndCache = {
+    files: {
+        [path: string]: null | string | object;
+    };
+    capProjectType: Map<string, CapProjectType | undefined>;
+};
 /**
  * Find root folder of the project containing the given file.
  *
@@ -30,10 +41,13 @@ export declare function getAppRootFromWebappPath(webappPath: string): Promise<st
  * - Freestyle application (non CAP) has in package.json dependency to @sap/ux-ui5-tooling and <appRoot>/ui5-local.yaml.
  *
  * @param path - path to check, e.g. to the manifest.json
- * @param memFs - optional mem-fs-editor instance
+ * @param options - optional mem-fs-editor instance or options object with optional memFs and cache
  * @returns - in case a supported app is found this function returns the appRoot and projectRoot path
  */
-export declare function findRootsForPath(path: string, memFs?: Editor): Promise<{
+export declare function findRootsForPath(path: string, options?: Editor | {
+    memFs?: Editor;
+    cache?: FileMapAndCache;
+}): Promise<{
     appRoot: string;
     projectRoot: string;
 } | null>;
@@ -42,10 +56,13 @@ export declare function findRootsForPath(path: string, memFs?: Editor): Promise<
  *
  * @param path - path inside CAP project
  * @param checkForAppRouter - if true, checks for app router in CAP project app folder
- * @param memFs - optional mem-fs-editor instance
+ * @param options - optional mem-fs-editor instance or options object with optional memFs and cache
  * @returns - CAP project root path
  */
-export declare function findCapProjectRoot(path: string, checkForAppRouter?: boolean, memFs?: Editor): Promise<string | null>;
+export declare function findCapProjectRoot(path: string, checkForAppRouter?: boolean, options?: Editor | {
+    memFs?: Editor;
+    cache?: FileMapAndCache;
+}): Promise<string | null>;
 /**
  * Find all app that are supported by Fiori tools for a given list of roots (workspace folders).
  * This is a convenient function to retrieve all apps. Same result can be achieved with call
@@ -62,7 +79,7 @@ export declare function findAllApps(wsFolders: readonly WorkspaceFolder[] | stri
  * @param options - find options
  * @param options.wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
  * @param options.artifacts - list of artifacts to search for: 'application', 'adaptation', 'extension' see FioriArtifactTypes
- * @param options.memFs
+ * @param options.memFs - optional mem-fs-editor instance
  * @returns - data structure containing the search results, for app e.g. as path to app plus files already parsed, e.g. manifest.json
  */
 export declare function findFioriArtifacts(options: {
@@ -80,4 +97,5 @@ export declare function findFioriArtifacts(options: {
 export declare function findCapProjects(options: {
     readonly wsFolders: WorkspaceFolder[] | string[];
 }): Promise<string[]>;
+export {};
 //# sourceMappingURL=search.d.ts.map

package/dist/project/search.js

@@ -136,6 +136,36 @@ async function getAppRootFromWebappPath(webappPath) {
     }
     return appRoot;
 }
+/**
+ * Type guard for Editor or Editor and FileMapAndCache.
+ *
+ * @param argument - argument to check
+ * @returns true if argument is Editor, false if it is FileMapAndCache
+ */
+function isEditor(argument) {
+    return argument.commit !== undefined;
+}
+/**
+ * Internal helper function to resolve options for findRootsForPath() and findCapProjectRoot().
+ *
+ * @param options - optional mem-fs-editor instance or options object with optional memFs and cache
+ * @returns memFs and cache
+ */
+function getFindOptions(options) {
+    let memFs;
+    let cache = { files: {}, capProjectType: new Map() };
+    if (options) {
+        // Check if options is Editor or { memFs?: Editor; cache?: FileMapAndCache }
+        if (isEditor(options)) {
+            memFs = options;
+        }
+        else {
+            memFs = options.memFs;
+            cache = options.cache ?? cache;
+        }
+    }
+    return { memFs, cache };
+}
 /**
  * Find the app root and project root folder for a given path. In case of apps in non CAP projects they are the same.
  * This function also validates if an app is supported by tools considering Fiori elements apps and SAPUI5
@@ -149,28 +179,25 @@ async function getAppRootFromWebappPath(webappPath) {
  * - Freestyle application (non CAP) has in package.json dependency to @sap/ux-ui5-tooling and <appRoot>/ui5-local.yaml.
  *
  * @param path - path to check, e.g. to the manifest.json
- * @param memFs - optional mem-fs-editor instance
+ * @param options - optional mem-fs-editor instance or options object with optional memFs and cache
  * @returns - in case a supported app is found this function returns the appRoot and projectRoot path
  */
-async function findRootsForPath(path, memFs) {
+async function findRootsForPath(path, options) {
     try {
+        const { memFs, cache } = getFindOptions(options);
         // Get the root of the app, that is where the package.json is, otherwise not supported
         const appRoot = await findProjectRoot(path, false, false, memFs);
         if (!appRoot) {
             return null;
         }
-        const appPckJson = await (0, file_1.readJSON)((0, path_1.join)(appRoot, constants_1.FileName.Package), memFs);
+        cache.files[path] ??= await (0, file_1.readJSON)((0, path_1.join)(appRoot, constants_1.FileName.Package), memFs);
+        const appPckJson = cache.files[path];
         // Check for most common app, Fiori elements with sapux=true in package.json
         if (appPckJson.sapux) {
             return findRootsWithSapux(appPckJson.sapux, path, appRoot);
         }
-        if ((await (0, cap_1.getCapProjectType)(appRoot, memFs)) !== undefined) {
-            // App is part of a CAP project, but doesn't have own package.json and is not mentioned in sapux array
-            // in root -> not supported
-            return null;
-        }
         // Check if app is included in CAP project
-        const projectRoot = await findCapProjectRoot(appRoot, undefined, memFs);
+        const projectRoot = await findCapProjectRoot(appRoot, undefined, { memFs, cache });
         if (projectRoot) {
             // App included in CAP
             return {
@@ -198,18 +225,23 @@ async function findRootsForPath(path, memFs) {
  *
  * @param path - path inside CAP project
  * @param checkForAppRouter - if true, checks for app router in CAP project app folder
- * @param memFs - optional mem-fs-editor instance
+ * @param options - optional mem-fs-editor instance or options object with optional memFs and cache
  * @returns - CAP project root path
  */
-async function findCapProjectRoot(path, checkForAppRouter = true, memFs) {
+async function findCapProjectRoot(path, checkForAppRouter = true, options) {
     try {
         if (!(0, path_1.isAbsolute)(path)) {
             return null;
         }
+        const { memFs, cache } = getFindOptions(options);
         const { root } = (0, path_1.parse)(path);
         let projectRoot = (0, path_1.dirname)(path);
         while (projectRoot !== root) {
-            if (await (0, cap_1.getCapProjectType)(projectRoot, memFs)) {
+            if (!cache.capProjectType.has(projectRoot)) {
+                cache.capProjectType.set(projectRoot, await (0, cap_1.getCapProjectType)(projectRoot, memFs));
+            }
+            const capProjectType = cache.capProjectType.get(projectRoot);
+            if (capProjectType) {
                 // We have found a CAP project as root. Check if the found app is not directly in CAP's 'app/' folder.
                 // Sometime there is a <CAP_ROOT>/app/package.json file that is used for app router (not an app)
                 // or skip app router check if checkForAppRouter is false and return the project root.
@@ -246,23 +278,26 @@ async function findAllApps(wsFolders, memFs) {
  * @returns - results as path to apps plus files already parsed, e.g. manifest.json
  */
 async function filterApplications(pathMap, memFs) {
-    const filterApplicationByManifest = async (manifestPath) => {
-        pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
-        const manifest = pathMap[manifestPath]; // cast needed as pathMap also allows strings and any other objects
-        // cast allowed, as this is the only place pathMap is filled for manifests
-        if (manifest['sap.app'].id && manifest['sap.app'].type === 'application') {
-            const roots = await findRootsForPath((0, path_1.dirname)(manifestPath), memFs);
+    const result = [];
+    const manifestPaths = Object.keys(pathMap.files).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
+    for (const manifestPath of manifestPaths) {
+        try {
+            // All UI5 apps have at least sap.app: { id: <ID>, type: "application" } in manifest.json
+            pathMap.files[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
+            const manifest = pathMap.files[manifestPath];
+            if (!manifest['sap.app']?.id || manifest['sap.app'].type !== 'application') {
+                continue;
+            }
+            const roots = await findRootsForPath((0, path_1.dirname)(manifestPath), { memFs, cache: pathMap });
             if (roots && !(await (0, file_1.fileExists)((0, path_1.join)(roots.appRoot, '.adp', constants_1.FileName.AdaptationConfig), memFs))) {
-                return { appRoot: roots.appRoot, projectRoot: roots.projectRoot, manifest: manifest, manifestPath };
+                result.push({ appRoot: roots.appRoot, projectRoot: roots.projectRoot, manifest, manifestPath });
             }
         }
-        throw new Error('Not relevant');
-    };
-    const isFulFilled = (input) => input.status === 'fulfilled';
-    const manifestPaths = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
-    return (await Promise.allSettled(manifestPaths.map(filterApplicationByManifest)))
-        .filter(isFulFilled) // returning only valid applications
-        .map(({ value }) => value);
+        catch {
+            // ignore exceptions for invalid manifests
+        }
+    }
+    return result;
 }
 /**
  * Filter adaptation projects from a list of files.
@@ -273,7 +308,7 @@ async function filterApplications(pathMap, memFs) {
  */
 async function filterAdaptations(pathMap, memFs) {
     const results = [];
-    const manifestAppDescrVars = Object.keys(pathMap).filter((path) => path.endsWith(constants_1.FileName.ManifestAppDescrVar));
+    const manifestAppDescrVars = Object.keys(pathMap.files).filter((path) => path.endsWith(constants_1.FileName.ManifestAppDescrVar));
     for (const manifestAppDescrVar of manifestAppDescrVars) {
         const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestAppDescrVar), memFs);
         const projectRoot = packageJsonPath ? (0, path_1.dirname)(packageJsonPath) : null;
@@ -292,14 +327,14 @@ async function filterAdaptations(pathMap, memFs) {
  */
 async function filterExtensions(pathMap, memFs) {
     const results = [];
-    const extensionConfigs = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.ExtConfigJson);
+    const extensionConfigs = Object.keys(pathMap.files).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.ExtConfigJson);
     for (const extensionConfig of extensionConfigs) {
         try {
             let manifest = null;
             let manifestPath = Object.keys(pathMap).find((path) => path.startsWith((0, path_1.dirname)(extensionConfig) + path_1.sep) && (0, path_1.basename)(path) === constants_1.FileName.Manifest);
             if (manifestPath) {
-                pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
-                manifest = pathMap[manifestPath];
+                pathMap.files[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
+                manifest = pathMap.files[manifestPath];
             }
             else {
                 const manifests = await (0, file_1.findBy)({
@@ -333,7 +368,7 @@ async function filterExtensions(pathMap, memFs) {
  */
 async function filterDotLibraries(pathMap, manifestPaths, memFs) {
     const dotLibraries = [];
-    const dotLibraryPaths = Object.keys(pathMap)
+    const dotLibraryPaths = Object.keys(pathMap.files)
         .filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Library)
         .map((path) => (0, path_1.dirname)(path))
         .filter((path) => !manifestPaths.map((manifestPath) => (0, path_1.dirname)(manifestPath)).includes(path));
@@ -354,12 +389,12 @@ async function filterDotLibraries(pathMap, manifestPaths, memFs) {
  */
 async function filterLibraries(pathMap, memFs) {
     const results = [];
-    const manifestPaths = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
+    const manifestPaths = Object.keys(pathMap.files).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
     results.push(...(await filterDotLibraries(pathMap, manifestPaths, memFs)));
     for (const manifestPath of manifestPaths) {
         try {
-            pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
-            const manifest = pathMap[manifestPath];
+            pathMap.files[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
+            const manifest = pathMap.files[manifestPath];
             if (manifest['sap.app'] && manifest['sap.app'].type === 'library') {
                 const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestPath), memFs);
                 const projectRoot = packageJsonPath ? (0, path_1.dirname)(packageJsonPath) : null;
@@ -383,11 +418,11 @@ async function filterLibraries(pathMap, memFs) {
  */
 async function filterComponents(pathMap, memFs) {
     const results = [];
-    const manifestPaths = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
+    const manifestPaths = Object.keys(pathMap.files).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
     for (const manifestPath of manifestPaths) {
         try {
-            pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
-            const manifest = pathMap[manifestPath];
+            pathMap.files[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
+            const manifest = pathMap.files[manifestPath];
             if (manifest['sap.app'] && manifest['sap.app'].type === 'component') {
                 const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestPath), memFs);
                 const projectRoot = packageJsonPath ? (0, path_1.dirname)(packageJsonPath) : null;
@@ -423,14 +458,14 @@ function getFilterFileNames(artifacts) {
  * @param options - find options
  * @param options.wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
  * @param options.artifacts - list of artifacts to search for: 'application', 'adaptation', 'extension' see FioriArtifactTypes
- * @param options.memFs
+ * @param options.memFs - optional mem-fs-editor instance
  * @returns - data structure containing the search results, for app e.g. as path to app plus files already parsed, e.g. manifest.json
  */
 async function findFioriArtifacts(options) {
     const results = {};
     const fileNames = getFilterFileNames(options.artifacts);
     const wsRoots = wsFoldersToRootPaths(options.wsFolders);
-    const pathMap = {};
+    const pathMap = { files: {}, capProjectType: new Map() };
     for (const root of wsRoots) {
         try {
             const foundFiles = await (0, file_1.findBy)({
@@ -439,7 +474,7 @@ async function findFioriArtifacts(options) {
                 excludeFolders,
                 memFs: options.memFs
             });
-            foundFiles.forEach((path) => (pathMap[path] = null));
+            foundFiles.forEach((path) => (pathMap.files[path] = null));
         }
         catch {
             // ignore exceptions during find

package/dist/types/library/index.d.ts

@@ -14,4 +14,72 @@ export interface ReuseLib {
     libRoot: string;
     description?: string;
 }
+/**
+ * Type definition for the library.xml file. Not complete, just parts we need.
+ */
+export interface LibraryXml {
+    library?: {
+        name: string;
+        vendor?: string;
+        version?: string;
+        copyright?: string;
+        title?: string;
+        documentation?: string;
+        dependencies?: {
+            dependency: {
+                libraryName: string;
+            }[];
+        };
+        appData?: {
+            manifest?: {
+                i18n?: string;
+                offline?: boolean;
+                deviceTypes?: {
+                    desktop?: boolean;
+                    phone?: boolean;
+                    tablet?: boolean;
+                };
+                supportedTheme?: string | string[];
+                contentDensities?: {
+                    cozy?: boolean;
+                    compact?: boolean;
+                };
+                'sap.fiori'?: {
+                    registrationId?: string;
+                    archeType?: string;
+                };
+                'sap.platform.abap'?: {
+                    uri?: string;
+                };
+                'sap.platform.hcp'?: {
+                    uri?: string;
+                };
+            };
+            selenium?: {
+                package?: string;
+            };
+            jscoverage?: {
+                exclude?: {
+                    name: string;
+                }[];
+            };
+            documentation?: {
+                indexUrl?: string;
+                resolve?: string;
+            };
+            releasenotes?: {
+                url?: string;
+                resolve?: string;
+            };
+            ownership?: {
+                component?: string | {
+                    name: string;
+                    modules?: {
+                        module: string[];
+                    };
+                }[];
+            };
+        };
+    };
+}
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap-ux/project-access",
-  "version": "1.29.7",
+  "version": "1.29.8",
   "description": "Library to access SAP Fiori tools projects",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
   "dependencies": {
     "fast-xml-parser": "4.4.1",
     "findit2": "2.2.3",
-    "json-parse-even-better-errors": "3.0.2",
+    "json-parse-even-better-errors": "4.0.0",
     "mem-fs": "2.1.0",
     "mem-fs-editor": "9.4.0",
     "semver": "7.5.4",