@ui5/task-adaptation 1.6.6 → 1.6.7

package/dist/adapters/commands/xsAppJsonMergeCommand.js

@@ -1,16 +1,17 @@
 import { merge } from "../../util/cf/xsAppJsonUtil.js";
 import { MergeCommand } from "./command.js";
+import { stringToBuffer, bufferToString } from "../../util/commonUtil.js";
 export default class XsAppJsonMergeCommand extends MergeCommand {
     accept = (filename) => filename === "xs-app.json";
     async execute(files, filename, appVariantContent) {
         const baseContent = files.get(filename);
         const xsAppJsonFiles = [
-            appVariantContent,
-            baseContent // base app xs-app.json comes last
+            bufferToString(appVariantContent),
+            baseContent ? bufferToString(baseContent) : undefined // base app xs-app.json comes last
         ].filter(file => file !== undefined);
         const result = merge(xsAppJsonFiles);
         if (result) {
-            files.set(filename, result);
+            files.set(filename, stringToBuffer(result));
         }
     }
 }

package/dist/adapters/previewAdapter.d.ts

@@ -5,7 +5,7 @@ import { UI5BuilderTools } from "../model/types.js";
 import IRepository from "../repositories/repository.js";
 import { IAdapter } from "./adapter.js";
 import CFAdapter from "./cfAdapter.js";
-import { AdaptCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
+import { AdaptCommandChain, ManifestUpdateCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
 export default class PreviewAdapter implements IAdapter {
     private configuration;
     private cfAdapter;
@@ -14,5 +14,6 @@ export default class PreviewAdapter implements IAdapter {
     constructor(configuration: IConfiguration, cfAdapter?: CFAdapter);
     createSetupCommandChain(appId: string, repository: IRepository): SetupCommandChain;
     createAdaptCommandChain(baseApp: BaseApp, appVariant: AppVariant): AdaptCommandChain;
+    createManifestPreviewCommandChain(baseApp: BaseApp, appVariant: AppVariant): ManifestUpdateCommandChain;
     createPostCommandChain(references: Map<string, string>, adaptationProject: AppVariant, ui5BuilderTools: UI5BuilderTools): PostCommandChain;
 }

package/dist/adapters/previewAdapter.js

@@ -25,6 +25,9 @@ export default class PreviewAdapter {
     createAdaptCommandChain(baseApp, appVariant) {
         return this.cfAdapter.createAdaptCommandChain(baseApp, appVariant);
     }
+    createManifestPreviewCommandChain(baseApp, appVariant) {
+        return this.cfAdapter.createManifestPreviewCommandChain(baseApp, appVariant);
+    }
     createPostCommandChain(references, adaptationProject, ui5BuilderTools) {
         const serviceCredentialsPromise = dependsOn(this.fetchEndpointsCommand);
         const previewPromise = dependsOn(this.fetchPreviewResourcesCommand);

package/dist/annotations/abapAnnotationManager.js

@@ -22,7 +22,7 @@ export default class AbapAnnotationManager {
         const i18nManager = new I18nManager(modelName, appVariantId, languages);
         const serviceRequestor = new ServiceRequestor(this.configuration, this.repository);
         const dataSourceManager = new DataSourceManager();
-        dataSourceManager.addDataSources(baseAppManifest["sap.app"]?.dataSources);
+        await dataSourceManager.addDataSources(baseAppManifest["sap.app"]?.dataSources);
         const annotationFiles = await dataSourceManager.createAnnotationFiles(languages, i18nManager, serviceRequestor);
         const i18nFiles = i18nManager.createFiles(i18nPathName);
         if (i18nManager.hasTranslations()) {

package/dist/annotations/dataSource/dataSourceManager.d.ts

@@ -3,10 +3,11 @@ import Language from "../../model/language.js";
 import ServiceRequestor from "../serviceRequestor.js";
 export default class DataSourceManager {
     private dataSources;
+    private shouldDownload;
     /**
      * Parses dataSources from manifest.json.
      * @param dataSourcesJson manifest.json/sap.app/dataSources node
      */
-    addDataSources(dataSourcesJson: any): void;
+    addDataSources(dataSourcesJson: any): Promise<void>;
     createAnnotationFiles(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<Map<string, string>>;
 }

package/dist/annotations/dataSource/dataSourceManager.js

@@ -1,20 +1,26 @@
-import DataSourceOData from "./dataSourceOData.js";
-import DataSourceODataAnnotation from "./dataSourceODataAnnotation.js";
 import path from "path/posix";
 export default class DataSourceManager {
     dataSources = new Array();
+    shouldDownload(dataSource, type) {
+        // is remote service, not local file
+        return dataSource.uri?.startsWith("/") &&
+            // no local metadata file and wasn't downloaded yet
+            !dataSource.settings?.ignoreAnnotationsFromMetadata &&
+            dataSource.type === type;
+    }
     /**
      * Parses dataSources from manifest.json.
      * @param dataSourcesJson manifest.json/sap.app/dataSources node
      */
-    addDataSources(dataSourcesJson) {
+    async addDataSources(dataSourcesJson) {
         if (!dataSourcesJson) {
             return;
         }
         const odataAnnotationMap = new Map();
         // Loop over OData first to collect linked annotation names
         for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            if (dataSource.uri?.startsWith("/") && dataSource.type === "OData") {
+            if (this.shouldDownload(dataSource, "OData")) {
+                const { default: DataSourceOData } = await import("./dataSourceOData.js");
                 const uri = path.normalize(dataSource.uri + "/$metadata");
                 const odata = new DataSourceOData(name, uri, dataSource);
                 odata.getAnnotations().forEach(annotation => odataAnnotationMap.set(annotation, uri));
@@ -23,10 +29,12 @@ export default class DataSourceManager {
         }
         // If ODataAnnotation is in OData annotations, pass metadata url to it
         for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            const uri = dataSource.uri;
-            const metadataUrl = odataAnnotationMap.get(name);
-            if (uri?.startsWith("/") && dataSource.type === "ODataAnnotation") {
-                this.dataSources.push(new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl));
+            if (this.shouldDownload(dataSource, "ODataAnnotation")) {
+                const { default: DataSourceODataAnnotation } = await import("./dataSourceODataAnnotation.js");
+                const uri = dataSource.uri;
+                const metadataUrl = odataAnnotationMap.get(name);
+                const odata = new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl);
+                this.dataSources.push(odata);
             }
         }
         for (const dataSource of this.dataSources) {

package/dist/appVariant.d.ts

@@ -1,6 +1,6 @@
 import { IChange } from "./model/types.js";
 export default class AppVariant {
-    readonly files: ReadonlyMap<string, string>;
+    readonly files: ReadonlyMap<string, Buffer>;
     readonly resources?: ReadonlyArray<Resource>;
     readonly id: string;
     readonly reference: string;
@@ -10,9 +10,10 @@ export default class AppVariant {
     movedFiles: Map<string, string>;
     private renaming;
     static fromWorkspace(workspace: IWorkspace, projectNamespace: string): Promise<AppVariant>;
-    static fromFiles(files: ReadonlyMap<string, string>): AppVariant;
+    static fromProject(): Promise<AppVariant>;
+    static fromFiles(files: ReadonlyMap<string, Buffer>): AppVariant;
     private constructor();
-    getProcessedFiles(): ReadonlyMap<string, string>;
+    getProcessedFiles(): ReadonlyMap<string, Buffer>;
     /**
      * Since we moved files, we need to update paths where they were referenced.
      * To do this we use renameMap function along with renaming ids.

package/dist/appVariant.js

@@ -1,5 +1,5 @@
-import { dotToUnderscore, isManifestChange } from "./util/commonUtil.js";
-import ResourceUtil from "./util/resourceUtil.js";
+import { bufferToJson, dotToUnderscore, isManifestChange } from "./util/commonUtil.js";
+import ResourceUtil, { TEXT_EXTENSIONS } from "./util/resourceUtil.js";
 import { posix as path } from "path";
 import { moveFile, moveFiles } from "./util/movingHandler/changeFileMoveHandler.js";
 import RenameFilesCommand from "./adapters/commands/renameFilesCommand.js";
@@ -16,11 +16,18 @@ export default class AppVariant {
     movedFiles = new Map();
     renaming = new Map();
     static async fromWorkspace(workspace, projectNamespace) {
-        const EXTENSIONS_TO_PROCESS = "js,json,xml,html,properties,change,appdescr_variant,ctrl_variant,ctrl_variant_change,ctrl_variant_management_change,variant,fioriversion,codeChange,xmlViewChange,context";
+        const EXTENSIONS_TO_PROCESS = Array.from(TEXT_EXTENSIONS).join(",");
         const resources = await workspace.byGlob(`/**/*.{${EXTENSIONS_TO_PROCESS}}`);
         const files = await ResourceUtil.toFileMap(resources, projectNamespace);
         return new AppVariant(files, resources);
     }
+    static async fromProject() {
+        // previewManifest only merges manifest changes, that is why we
+        // just need the app variant descriptor and *.change files from the workspace.
+        const EXTENSIONS_TO_PROCESS = "change,appdescr_variant";
+        const files = await ResourceUtil.byGlobInProject(`/**/*.{${EXTENSIONS_TO_PROCESS}}`);
+        return new AppVariant(files);
+    }
     static fromFiles(files) {
         return new AppVariant(files);
     }
@@ -30,9 +37,9 @@ export default class AppVariant {
         }
         this.files = files;
         this.resources = resources;
-        const manifestString = files.get("manifest.appdescr_variant");
-        this.validateManifest(manifestString);
-        const { reference, id, layer, content } = JSON.parse(manifestString);
+        const manifestBuffer = files.get("manifest.appdescr_variant");
+        this.validateManifest(manifestBuffer);
+        const { reference, id, layer, content } = bufferToJson(manifestBuffer);
         this.reference = reference;
         this.id = id;
         validateAppId(id);
@@ -70,9 +77,9 @@ export default class AppVariant {
         const changeFileChanges = [];
         this.files.forEach((content, filename) => {
             if (filename.endsWith(CHANGES_EXT)) {
-                const change = JSON.parse(content);
                 if (isManifestChange(filename, content)) {
                     const { newFilename } = moveFile(filename, content, this.prefix, this.id);
+                    const change = bufferToJson(content);
                     this.updateRelativePaths(change, newFilename);
                     changeFileChanges.push(change);
                 }

package/dist/baseApp.d.ts

@@ -15,13 +15,13 @@ export interface IManifestInfo extends IManifestIdVersion {
  * @param files - Map of all files
  * @returns Map with .js files replaced by -dbg.js content where applicable
  */
-export declare function preProcessFiles(files: ReadonlyMap<string, string>): Map<string, string>;
+export declare function preProcessFiles(files: ReadonlyMap<string, Buffer>): Map<string, Buffer>;
 export default class BaseApp {
     readonly id: string;
     readonly version: string;
     readonly i18nPath: string;
-    readonly files: ReadonlyMap<string, string>;
-    static fromFiles(files: ReadonlyMap<string, string>): BaseApp;
+    readonly files: ReadonlyMap<string, Buffer>;
+    static fromFiles(files: ReadonlyMap<string, Buffer>): BaseApp;
     private constructor();
     private extractI18nPathFromManifest;
     private VALIDATION_RULES;

package/dist/baseApp.js

@@ -1,4 +1,4 @@
-import { trimExtension } from "./util/commonUtil.js";
+import { bufferToJson, trimExtension } from "./util/commonUtil.js";
 import { validateAppId } from "./util/validator/validator.js";
 const IGNORE_FILES = [
     "manifest-bundle.zip",
@@ -48,11 +48,11 @@ export default class BaseApp {
             throw new Error("Original application sources are empty");
         }
         this.files = preProcessFiles(files);
-        const manifestString = files.get("manifest.json");
-        if (!manifestString) {
+        const manifestBuffer = this.files.get("manifest.json");
+        if (!manifestBuffer) {
             throw new Error("Original application should have manifest.json in root folder");
         }
-        const manifest = JSON.parse(manifestString);
+        const manifest = bufferToJson(manifestBuffer);
         this.id = manifest["sap.app"]?.id;
         this.version = manifest["sap.app"]?.applicationVersion?.version;
         this.validateProperty(this.id, "sap.app/id");

package/dist/bundle.js

@@ -6323,7 +6323,8 @@ _Helper = {
         aSegments = sPath.split("/");
         aSegments.pop();
         while (aSegments.length) {
-          if (aAncestors.indexOf(aSegments.join("/")) >= 0) {
+          const sPrefix = aSegments.join("/");
+          if (aAncestors.includes(sPrefix) || aAncestors.includes(sPrefix + "/*")) {
             mChildren[sPath] = true;
             break;
           }
@@ -6503,8 +6504,20 @@ _Helper = {
     for (const sKey in oSource) {
       const vSourceProperty = oSource[sKey];
       const vTargetProperty = oTarget[sKey];
-      if (vSourceProperty && vTargetProperty && typeof vSourceProperty === "object" && !Array.isArray(vSourceProperty)) {
-        _Helper.copyETags(vSourceProperty, vTargetProperty);
+      if (vSourceProperty && vTargetProperty) {
+        if (Array.isArray(vSourceProperty)) {
+          if (vTargetProperty.$byPredicate) {
+            vSourceProperty.forEach(function (oSourceElement) {
+              const sPredicate = _Helper.getPrivateAnnotation(oSourceElement, "predicate");
+              const oTargetElement = vTargetProperty.$byPredicate[sPredicate];
+              if (oTargetElement) {
+                _Helper.copyETags(oSourceElement, oTargetElement);
+              }
+            });
+          }
+        } else if (typeof vSourceProperty === "object") {
+          _Helper.copyETags(vSourceProperty, vTargetProperty);
+        }
       }
     }
   },
@@ -6583,6 +6596,9 @@ _Helper = {
   },
   createMissing: function (oObject, aSegments) {
     aSegments.reduce(function (oCurrent, sSegment, i) {
+      if (oCurrent === null) {
+        return null;
+      }
       if (!((sSegment in oCurrent))) {
         if (i + 1 < aSegments.length) {
           oCurrent[sSegment] = {};
@@ -7037,7 +7053,7 @@ _Helper = {
   },
   getUsedPaths: function (aPaths, mQueryOptions) {
     function isRelated(sPath0, sPath1) {
-      return _Helper.hasPathPrefix(sPath0, sPath1) || _Helper.hasPathPrefix(sPath1, sPath0);
+      return _Helper.isAffectedBy(sPath0, sPath1) || _Helper.isAffectedBy(sPath1, sPath0);
     }
     function isUsed(sPath, mQueryOptionsForPath) {
       let bPathMatchedExpand = false;
@@ -7119,15 +7135,15 @@ _Helper = {
         return i === 0 && bSkipFirstSegment || sSegment === "$count" || fnFetchMetadata(sRootMetaPath + "/" + aSegments.slice(0, i + 1).join("/")).getResult().$kind === "Property";
       });
     }
-    if (aPaths.indexOf("") >= 0) {
+    if (aPaths.includes("")) {
       throw new Error("Unsupported empty navigation property path");
     }
-    if (aPaths.indexOf("*") >= 0) {
+    if (aPaths.includes("*")) {
       aSelects = (mCacheQueryOptions && mCacheQueryOptions.$select || []).slice();
       if (sMessagesPath && !aSelects.includes(sMessagesPath)) {
         aSelects.push(sMessagesPath);
       }
-    } else if (mCacheQueryOptions && mCacheQueryOptions.$select && mCacheQueryOptions.$select.indexOf("*") < 0) {
+    } else if (mCacheQueryOptions && mCacheQueryOptions.$select && !mCacheQueryOptions.$select.includes("*")) {
       _Helper.addChildrenWithAncestor(aPaths, mCacheQueryOptions.$select, mSelects);
       _Helper.addChildrenWithAncestor(mCacheQueryOptions.$select, aPaths, mSelects);
       if (sMessagesPath && aPaths.includes(sMessagesPath)) {
@@ -7608,7 +7624,7 @@ _Helper = {
           }
           if (fnCheckKeyPredicate && fnCheckKeyPredicate(sPath)) {
             sTargetPredicate = _Helper.getPrivateAnnotation(oTarget, "predicate");
-            if (sSourcePredicate !== sTargetPredicate) {
+            if (sTargetPredicate && sTargetPredicate !== sSourcePredicate) {
               throw new Error("Key predicate of '" + sPath + "' changed from " + sTargetPredicate + " to " + sSourcePredicate);
             }
           } else {

package/dist/cache/cacheHolder.d.ts

@@ -1,8 +1,17 @@
 export default class CacheHolder {
     private static TEMP_TASK_DIR;
     static getTempDir(...paths: string[]): string;
-    static read(repoName: string, token: string): Promise<Map<string, string>>;
-    static write(repoName: string, token: string, files: Map<string, string>): Promise<void>;
+    static read(repoName: string, token: string): Promise<Map<string, Buffer>>;
+    /**
+     * Read the most recently cached files for the given repo, without knowing
+     * the cachebuster token up front. The @cached() decorator on
+     * IRepository.fetch calls delete(repoName) before every write, so there is
+     * at most one token subdirectory under <repoName>/ at any time.
+     * Returns an empty map if the repo has never been fetched
+     * (i.e. no full build has run yet).
+     */
+    static readLatest(repoName: string): Promise<Map<string, Buffer>>;
+    static write(repoName: string, token: string, files: Map<string, Buffer>): Promise<void>;
     private static isValid;
     /**
      * Clears cached files by repo name and token

package/dist/cache/cacheHolder.js

@@ -18,6 +18,28 @@ export default class CacheHolder {
         }
         return Promise.resolve(new Map());
     }
+    /**
+     * Read the most recently cached files for the given repo, without knowing
+     * the cachebuster token up front. The @cached() decorator on
+     * IRepository.fetch calls delete(repoName) before every write, so there is
+     * at most one token subdirectory under <repoName>/ at any time.
+     * Returns an empty map if the repo has never been fetched
+     * (i.e. no full build has run yet).
+     */
+    static async readLatest(repoName) {
+        if (!this.isValid(repoName, "repoName")) {
+            throw new Error(`Cache read requires 'repoName' to be provided`);
+        }
+        const repoDir = this.getTempDir(repoName);
+        if (!fs.existsSync(repoDir)) {
+            throw new Error(`No cache found for '${repoName}'. Run a full build first.`);
+        }
+        const [tokenDir] = await fsPromises.readdir(repoDir);
+        if (!tokenDir) {
+            throw new Error(`Cache directory for '${repoName}' is empty. Run a full build first.`);
+        }
+        return ResourceUtil.byGlob(path.join(repoDir, tokenDir), "**/*");
+    }
     static async write(repoName, token, files) {
         this.delete(repoName);
         if (this.isValid(repoName, "repoName") && this.isValid(token, "token")) {
@@ -74,7 +96,7 @@ export function cached() {
             let files = await CacheHolder.read(appName, token);
             CacheHolder.clearOutdatedExcept(appName);
             if (files.size === 0) {
-                log.verbose(`No cache for repo '${appName}' with token '${token}'. Fetching from HTML5 Repository.`);
+                log.verbose(`No cache for repo '${appName}' with token '${token}'. Fetching from repository.`);
                 files = await originalValue.apply(this, args);
                 await CacheHolder.write(appName, token, files);
             }

package/dist/index.d.ts

@@ -2,5 +2,14 @@ import { ITaskParameters } from "./model/types.js";
 /**
  * Creates an appVariant bundle from the provided resources.
  */
-declare const _default: ({ workspace, options, taskUtil }: ITaskParameters) => Promise<ReadonlyMap<string, string>>;
+declare const _default: ({ workspace, options, taskUtil }: ITaskParameters) => Promise<ReadonlyMap<string, Buffer<ArrayBufferLike>>>;
 export default _default;
+/**
+ * Preview-time entry point (CF only). Produces the same manifest.json a
+ * full build would produce, without going to the HTML5 Repo.
+ * Precondition is a full build must have run at least once so the base app
+ * files are cached by the @cached() decorator on HTML5Repository.fetch. If
+ * the cache is empty, this throws with a message directing the user to run
+ * a full build first.
+ */
+export declare function previewManifest({ options }: ITaskParameters): Promise<any>;

package/dist/index.js

@@ -1,5 +1,5 @@
 import * as dotenv from "dotenv";
-import { getReferences, logBuilderVersion } from "./util/commonUtil.js";
+import { bufferToString, getReferences, logBuilderVersion } from "./util/commonUtil.js";
 import AppVariant from "./appVariant.js";
 import BaseApp from "./baseApp.js";
 import { initialize } from "./landscapeConfiguration.js";
@@ -14,7 +14,7 @@ export default async ({ workspace, options, taskUtil }) => {
     };
     dotenv.config();
     logBuilderVersion();
-    const { repository, adapter } = initialize(options.configuration);
+    const { repository, adapter } = await initialize(options.configuration);
     const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
     const setupCommandChain = adapter.createSetupCommandChain(adaptationProject.reference, repository);
     await setupCommandChain.execute();
@@ -34,11 +34,31 @@ export default async ({ workspace, options, taskUtil }) => {
         return adapter.createAdaptCommandChain(baseApp, appVariant).execute();
     };
     let files = await fetchFilesPromises.shift(); // original app files
-    for (const appVariantFiles of fetchFilesPromises) {
-        files = await adapt(files, AppVariant.fromFiles(await appVariantFiles));
+    for (const appVariantFilesPromise of fetchFilesPromises) {
+        const appVariantFiles = await appVariantFilesPromise;
+        files = await adapt(files, AppVariant.fromFiles(appVariantFiles));
     }
     files = await adapt(files, adaptationProject);
     const references = getReferences(appVariants, adaptationProject.id);
     return adapter.createPostCommandChain(references, adaptationProject, ui5BuilderTools).execute(files);
 };
+/**
+ * Preview-time entry point (CF only). Produces the same manifest.json a
+ * full build would produce, without going to the HTML5 Repo.
+ * Precondition is a full build must have run at least once so the base app
+ * files are cached by the @cached() decorator on HTML5Repository.fetch. If
+ * the cache is empty, this throws with a message directing the user to run
+ * a full build first.
+ */
+export async function previewManifest({ options }) {
+    const { repository, adapter } = await initialize(options.configuration, { useCacheRepository: true });
+    const adaptationProject = await AppVariant.fromProject();
+    const [baseAppResource] = await repository.getAppVariantIdHierarchy(adaptationProject.reference);
+    const cachedBaseAppFiles = await repository.fetch(baseAppResource);
+    const baseApp = BaseApp.fromFiles(cachedBaseAppFiles);
+    const files = new Map(cachedBaseAppFiles);
+    const manifestPreviewCommandChain = adapter.createManifestPreviewCommandChain(baseApp, adaptationProject);
+    await manifestPreviewCommandChain.execute(files, "manifest.json");
+    return JSON.parse(bufferToString(files.get("manifest.json")));
+}
 //# sourceMappingURL=index.js.map

package/dist/landscapeConfiguration.d.ts

@@ -1,9 +1,9 @@
-import { IConfiguration } from "./model/types.js";
+import { IConfiguration, IInitializeOptions } from "./model/types.js";
 import { IAdapter } from "./adapters/adapter.js";
 import IRepository from "./repositories/repository.js";
 import IAnnotationManager from "./annotations/annotationManager.js";
-export declare function initialize(configuration: IConfiguration): {
+export declare function initialize(configuration: IConfiguration, options?: IInitializeOptions): Promise<{
     adapter: IAdapter;
     repository: IRepository;
     annotationManager: IAnnotationManager;
-};
+}>;

package/dist/landscapeConfiguration.js

@@ -1,39 +1,31 @@
-import AbapAdapter from "./adapters/abapAdapter.js";
-import CFAdapter from "./adapters/cfAdapter.js";
-import PreviewAdapter from "./adapters/previewAdapter.js";
-import AbapRepository from "./repositories/abapRepository.js";
-import HTML5Repository from "./repositories/html5Repository.js";
-import LocalRepository from "./repositories/localRepository.js";
-import AbapAnnotationManager from "./annotations/abapAnnotationManager.js";
-import CFAnnotationManager from "./annotations/cfAnnotationManager.js";
 import CFValidator from "./util/validator/cfValidator.js";
-import AbapValidator from "./util/validator/abapValidator.js";
 import { isOneOf } from "./util/validator/validator.js";
 import { LANDSCAPE_TYPES } from "./model/configuration.js";
 import { getLogger } from "@ui5/logger";
+import AbapValidator from "./util/validator/abapValidator.js";
 import LocalAnnotationManager from "./annotations/localAnnotationManager.js";
 const log = getLogger("@ui5/task-adaptation::LandscapeConfiguration");
-export function initialize(configuration) {
-    const type = getTypeByConfiguration(configuration);
+export async function initialize(configuration, options = {}) {
+    const type = await getTypeByConfiguration(configuration);
     const enhancedConfig = { ...configuration, type };
-    const repository = getRepository(enhancedConfig);
-    const annotationManager = getAnnotationManager(enhancedConfig, repository);
+    const repository = await getRepository(enhancedConfig, options);
+    const annotationManager = await getAnnotationManager(enhancedConfig, repository);
     return {
-        adapter: getAdapter(enhancedConfig, annotationManager),
+        adapter: await getAdapter(enhancedConfig, annotationManager),
         repository,
         annotationManager
     };
 }
-function getTypeByConfiguration(configuration) {
-    const validators = [
-        new CFValidator(),
-        new AbapValidator(),
-    ];
+async function getTypeByConfiguration(configuration) {
     if (isOneOf(LANDSCAPE_TYPES, configuration.type)) {
         return configuration.type;
     }
     else {
         log.warn("Deprecated behavior: type is not specified or invalid. Should be either 'cf' or 'abap'. Trying to detect the type based on provided configuration");
+        const validators = [
+            new CFValidator(),
+            new AbapValidator(),
+        ];
         for (const validator of validators) {
             try {
                 validator.validateConfiguration(configuration);
@@ -46,41 +38,59 @@ function getTypeByConfiguration(configuration) {
         throw new Error("'type' should be specified in ui5.yaml configuration: 'cf' or 'abap'");
     }
 }
-function getAdapter(configuration, annotationManager) {
+async function getAdapter(configuration, annotationManager) {
     if (isPreview()) {
+        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
         return new PreviewAdapter(configuration);
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapAdapter } = await import("./adapters/abapAdapter.js");
             return new AbapAdapter(annotationManager);
-        case "cf":
+        }
+        case "cf": {
+            const { default: CFAdapter } = await import("./adapters/cfAdapter.js");
             return new CFAdapter(configuration);
+        }
         default:
             throw new Error(`No adapter found for the given configuration type '${configuration.type}'`);
     }
 }
-function getRepository(configuration) {
+async function getRepository(configuration, options) {
+    if (options.useCacheRepository) {
+        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
+        return new CacheRepository(configuration);
+    }
     if (isLocal()) {
+        const { default: LocalRepository } = await import("./repositories/localRepository.js");
         return new LocalRepository();
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
             return new AbapRepository(configuration);
-        case "cf":
+        }
+        case "cf": {
+            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
             return new HTML5Repository(configuration);
+        }
         default:
             throw new Error(`No repository found for the given configuration type '${configuration.type}'`);
     }
 }
-function getAnnotationManager(configuration, repository) {
+async function getAnnotationManager(configuration, repository) {
     if (isLocal()) {
         return new LocalAnnotationManager();
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
             return new AbapAnnotationManager(configuration, repository);
-        case "cf":
+        }
+        case "cf": {
+            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
             return new CFAnnotationManager();
+        }
         default:
             throw new Error(`No annotation manager found for the given configuration type '${configuration.type}'`);
     }

package/dist/model/types.d.ts

@@ -129,5 +129,8 @@ export type ServiceCredentials = {
     } | string>;
     "sap.cloud.service"?: string;
 };
-export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, string>>>;
+export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, Buffer>>>;
 export { IConfiguration };
+export interface IInitializeOptions {
+    useCacheRepository?: boolean;
+}

package/dist/repositories/abapProvider.js

@@ -1,11 +1,11 @@
 import { createAbapServiceProvider } from "@sap-ux/system-access";
 import { getLogger } from "@ui5/logger";
-import AbapValidator from "../util/validator/abapValidator.js";
+import AbapConnectionValidator from "../util/validator/abapConnectionValidator.js";
 const log = getLogger("@ui5/task-adaptation::AbapProvider");
 log.debug = (message) => log.verbose(message);
 export default class AbapProvider {
     provider = null;
-    abapValidator = new AbapValidator();
+    abapValidator = new AbapConnectionValidator();
     async get({ target, destination }) {
         if (!this.provider) {
             const abapTarget = this.abapValidator.validateAndGetAbapTarget(target, destination);

package/dist/repositories/abapRepository.d.ts

@@ -11,6 +11,6 @@ export default class AbapRepository implements IRepository {
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
     downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
     getMetadata(id: string): Promise<IMetadata>;
-    fetch(resource: IAbapResource): Promise<Map<string, string>>;
+    fetch(resource: IAbapResource): Promise<Map<string, Buffer>>;
 }
 export {};

package/dist/repositories/cacheRepository.d.ts

@@ -0,0 +1,10 @@
+import ICachedResource from "../cache/cachedResource.js";
+import { IConfiguration } from "../model/types.js";
+import IRepository from "./repository.js";
+export default class CacheRepository implements IRepository {
+    private configuration;
+    constructor(configuration: IConfiguration);
+    getAppVariantIdHierarchy(_appId: string): Promise<ICachedResource[]>;
+    fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
+    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+}