@ui5/task-adaptation 1.6.8 → 1.7.0

package/dist/repositories/cacheRepository.d.ts

@@ -1,10 +1,9 @@
 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[]>;
+    private repository;
+    constructor(repository: IRepository);
+    getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
     fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(uri: string): Promise<string>;
 }

package/dist/repositories/cacheRepository.js

@@ -1,29 +1,21 @@
 import CacheHolder from "../cache/cacheHolder.js";
 export default class CacheRepository {
-    configuration;
-    constructor(configuration) {
-        this.configuration = configuration;
+    repository;
+    constructor(repository) {
+        this.repository = repository;
     }
-    async getAppVariantIdHierarchy(_appId) {
-        const { appName } = this.configuration;
-        if (!appName) {
-            throw new Error("previewManifest requires 'appName' in the ui5.yaml configuration");
+    async getAppVariantIdHierarchy(appId) {
+        const mergedResource = CacheHolder.mergedResource(appId);
+        if (await CacheHolder.hasDirectory(mergedResource)) {
+            return [mergedResource];
         }
-        return [{
-                appName,
-                cacheBusterToken: Promise.resolve("")
-            }];
+        return this.repository.getAppVariantIdHierarchy(appId);
     }
     async fetch(resource) {
-        const appName = resource.appName;
-        const cachedFiles = await CacheHolder.readLatest(appName);
-        if (cachedFiles.size === 0) {
-            throw new Error(`No cached base app found for '${appName}'. Please check the appName or run a full build first to populate the cache.`);
-        }
-        return cachedFiles;
+        return this.repository.fetch(resource);
     }
     downloadAnnotationFile(uri) {
-        throw new Error(`Download annotation file for uri: ${uri} is not available for CacheRepository.`);
+        return this.repository.downloadAnnotationFile(uri);
     }
 }
 //# sourceMappingURL=cacheRepository.js.map

package/dist/repositories/html5Repository.d.ts

@@ -18,5 +18,5 @@ export default class HTML5Repository implements IRepository {
     private requestMetadata;
     private getAppZipEntries;
     private download;
-    downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(_uri: string): Promise<string>;
 }

package/dist/repositories/html5Repository.js

@@ -25,7 +25,7 @@ export default class HTML5Repository {
         }
         return [{
                 appName,
-                cacheBusterToken: this.getMetadata().then(metadata => metadata.changedOn),
+                token: this.getMetadata().then(metadata => metadata.changedOn),
                 appVersion,
                 appHostId,
             }];
@@ -118,7 +118,7 @@ export default class HTML5Repository {
     }
     downloadAnnotationFile(_uri) {
         log.verbose("No annotation processing in CF");
-        return Promise.resolve(new Map());
+        return Promise.resolve("");
     }
 }
 __decorate([

package/dist/repositories/localRepository.d.ts

@@ -4,7 +4,7 @@ export interface ILocalResource extends ICachedResource {
     absolutePath: string;
 }
 export default class LocalRepository implements IRepository {
-    downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(_uri: string): Promise<string>;
     getAppVariantIdHierarchy(appId: string): Promise<ILocalResource[]>;
     fetch(resource: ILocalResource): Promise<Map<string, Buffer>>;
     private buildManifestIndex;

package/dist/repositories/localRepository.js

@@ -7,7 +7,7 @@ const log = getLogger("@ui5/task-adaptation::LocalRepository");
 export default class LocalRepository {
     async downloadAnnotationFile(_uri) {
         log.verbose("Downloading annotation files is not supported in LocalRepository.");
-        return new Map();
+        return "";
     }
     async getAppVariantIdHierarchy(appId) {
         const items = [];
@@ -26,7 +26,7 @@ export default class LocalRepository {
             }
             items.push({
                 appName: currentAppId,
-                cacheBusterToken: Promise.resolve("local"),
+                token: Promise.resolve("local"),
                 absolutePath: entry.absolutePath,
             });
             if (entry.isVariant) {

package/dist/repositories/repository.d.ts

@@ -2,5 +2,5 @@ import ICachedResource from "../cache/cachedResource.js";
 export default interface IRepository {
     getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
     fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(uri: string): Promise<string>;
 }

package/dist/util/commonUtil.d.ts

@@ -1,6 +1,4 @@
-import { IConfiguration } from "../model/types.js";
-import Language from "../model/language.js";
-import AppVariant from "../appVariant.js";
+export declare function retryOnError(maxRetries: number): MethodDecorator;
 export declare function dotToUnderscore(value: string): string;
 export declare function bufferToString(buffer: Buffer): string;
 export declare function bufferToJson(buffer: Buffer): any;
@@ -11,15 +9,9 @@ export declare function validateConfiguration<T extends object>(options: T, prop
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
 export declare function escapeRegex(update: string): string;
 export declare function insertInArray<T>(array: T[], index: number, insert: T): void;
-export declare function writeTempAnnotations({ writeTempFiles }: IConfiguration, name: string, language: Language, content: string): void;
 export declare function trimExtension(filePath: string): string;
 export declare function traverse(json: any, paths: string[], callback: (json: any, key: string | number, paths: string[]) => void): void;
 export declare function logBuilderVersion(): void;
 export declare function logBetaUsage(): void;
 export declare function getUniqueName(existingNames: string[], template: string): string;
 export declare function isManifestChange(filename: string, content: Buffer): boolean;
-/**
- * 4p. Reference map contains searchTerm as key and replacement as value. Base
- * id and app variant ids are renamed to adaptation project id.
- */
-export declare function getReferences(appVariants: AppVariant[], adaptationProjectId: string): Map<string, string>;

package/dist/util/commonUtil.js

@@ -2,10 +2,37 @@ import * as Log from "@ui5/logger";
 import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { posix as path } from "path";
+import ServerError from "../model/serverError.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const log = Log.getLogger("rollup-plugin-ui5-resolve-task-adaptation");
 const CHANGES_EXT = ".change";
 const MANIFEST_CHANGE = "appdescr_";
+export function retryOnError(maxRetries) {
+    return (_target, _propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            let retries = 0;
+            while (true) {
+                try {
+                    return await originalMethod.apply(this, args);
+                }
+                catch (error) {
+                    if (error instanceof ServerError) {
+                        if (retries === maxRetries) {
+                            throw new Error(`Error occurred: ${error.message}. Please try again if this is a temporary issue. If not, please create a ticket on CA-UI5-ABA-AIDX`);
+                        }
+                        retries++;
+                    }
+                    else {
+                        const message = error?.response?.data ?? error.message;
+                        throw new Error(`Failed to fetch annotation by '${args[0]}': ${message}`);
+                    }
+                }
+            }
+        };
+        return descriptor;
+    };
+}
 export function dotToUnderscore(value) {
     return value.replace(/\./g, "_");
 }
@@ -40,18 +67,6 @@ export function escapeRegex(update) {
 export function insertInArray(array, index, insert) {
     array.splice(index, 0, insert);
 }
-export function writeTempAnnotations({ writeTempFiles }, name, language, content) {
-    const TEMP_DIST_FOLDER = path.join(process.cwd(), "dist-debug", name);
-    if (writeTempFiles) {
-        if (!fs.existsSync(TEMP_DIST_FOLDER)) {
-            fs.mkdirSync(TEMP_DIST_FOLDER, { recursive: true });
-        }
-        if (language) {
-            name += "-" + language.i18n;
-        }
-        fs.writeFileSync(path.join(TEMP_DIST_FOLDER, name + ".xml"), content);
-    }
-}
 export function trimExtension(filePath) {
     return filePath.replace(/\.[^/.]+$/, "");
 }
@@ -113,21 +128,4 @@ export function isManifestChange(filename, content) {
     }
     return false;
 }
-/**
- * 4p. Reference map contains searchTerm as key and replacement as value. Base
- * id and app variant ids are renamed to adaptation project id.
- */
-export function getReferences(appVariants, adaptationProjectId) {
-    const references = new Map();
-    appVariants.forEach((variant, i) => {
-        if (i === 0) {
-            references.set(variant.reference, adaptationProjectId);
-        }
-        if (variant.id !== adaptationProjectId) {
-            references.set(variant.id, adaptationProjectId);
-        }
-        variant.getRenamingForMovedFiles().forEach((value, key) => references.set(key, value));
-    });
-    return references;
-}
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/fsUtil.js

@@ -41,8 +41,7 @@ export default class FsUtil {
         const fileReadTasks = entries
             .filter(entry => entry.isFile())
             .map(async (entry) => {
-            const parentPath = entry.parentPath ?? entry.path; // node v20.11.0 fallback
-            const entryPath = path.join(parentPath, entry.name);
+            const entryPath = path.join(entry.parentPath, entry.name);
             const relativeFilePath = path.relative(rootDirectory, entryPath).replaceAll("\\", "/");
             const content = await fs.readFile(entryPath);
             return [relativeFilePath, content];

package/dist/util/movingHandler/changeFileMoveHandler.d.ts

@@ -1,6 +1,7 @@
 export declare const moveFiles: (inputFiles: ReadonlyMap<string, Buffer>, prefix: string, id: string) => {
     files: Map<string, Buffer<ArrayBufferLike>>;
     renamingPaths: Map<string, string>;
+    movedFiles: Map<string, string>;
 };
 export declare const moveFile: (filename: string, content: Buffer, prefix: string, id: string) => {
     newFilename: string;

package/dist/util/movingHandler/changeFileMoveHandler.js

@@ -49,13 +49,21 @@ function getPathWithoutExtensions(filename) {
 }
 export const moveFiles = (inputFiles, prefix, id) => {
     const files = new Map();
-    let renamingPaths = new Map();
+    const renamingPaths = new Map();
+    // Maps original filename -> new filename for files that were actually
+    // moved, so callers can resolve the new location of an omitted resource.
+    const movedFiles = new Map();
     inputFiles.forEach((content, filename) => {
         const { newFilename, renamingPath } = moveFile(filename, content, prefix, id);
         files.set(newFilename, content);
-        renamingPaths = new Map([...renamingPaths, ...renamingPath]);
+        for (const [from, to] of renamingPath) {
+            renamingPaths.set(from, to);
+        }
+        if (newFilename !== filename) {
+            movedFiles.set(filename, newFilename);
+        }
     });
-    return { files, renamingPaths };
+    return { files, renamingPaths, movedFiles };
 };
 export const moveFile = (filename, content, prefix, id) => {
     let newFilename = filename;

package/dist/util/referencesBuilder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fluent builder for the reference map (old id → adaptation project id) used to
+ * rename files. Chain `addReferences` and finish with `build`.
+ */
+export default class ReferencesBuilder {
+    private readonly references;
+    /**
+     * Adds the references derived from the app variant id hierarchy stored in
+     * the given files' manifest.
+     */
+    addReferences(files: ReadonlyMap<string, Buffer>, adaptationProjectId: string): this;
+    addReference(from: string, to: string): this;
+    build(): Map<string, string>;
+    private getReferences;
+}

package/dist/util/referencesBuilder.js

@@ -0,0 +1,35 @@
+import BaseApp from "../baseApp.js";
+/**
+ * Fluent builder for the reference map (old id → adaptation project id) used to
+ * rename files. Chain `addReferences` and finish with `build`.
+ */
+export default class ReferencesBuilder {
+    references = new Map();
+    /**
+     * Adds the references derived from the app variant id hierarchy stored in
+     * the given files' manifest.
+     */
+    addReferences(files, adaptationProjectId) {
+        const hierarchy = BaseApp.getAppVariantHierarchy(files);
+        const references = this.getReferences(hierarchy, adaptationProjectId);
+        references.forEach((value, key) => this.references.set(key, value));
+        return this;
+    }
+    addReference(from, to) {
+        this.references.set(from, to);
+        return this;
+    }
+    build() {
+        return this.references;
+    }
+    getReferences(appVariantIdHierarchy, adaptationProjectId) {
+        const references = new Map();
+        for (const appVariantId of appVariantIdHierarchy) {
+            if (appVariantId !== adaptationProjectId && !references.has(appVariantId)) {
+                references.set(appVariantId, adaptationProjectId);
+            }
+        }
+        return references;
+    }
+}
+//# sourceMappingURL=referencesBuilder.js.map

package/dist/util/renaming/fileRenamer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Renames references (old id → adaptation project id) across all text files in
+ * place, leaving i18n .properties files, their keys and SAPUI5 dependency ids
+ * untouched.
+ */
+export default class FileRenamer {
+    /**
+     * 1p. i18n.properties are not renamed and property keys are ignored during
+     * the renaming across the files. Stateless: does not use `this`.
+     * @param files - all files both base and appVariants
+     * @param references - Reference maps of the app variant
+     */
+    static rename(files: Map<string, Buffer>, references: Map<string, string>): void;
+}
+/**
+ * Snapshots the JSON paths that must survive renaming (e.g.
+ * sap.ui5/appVariantIdHierarchy, dependencies), runs the decorated method, then
+ * restores them. The decorated method receives a Map of files (filename →
+ * Buffer): every file a handler `accept`s is parsed, snapshotted before the
+ * renaming and restored + written back after. Each matching file gets its own
+ * handler instance so one file's snapshot can't clobber another's.
+ */
+export declare function restoreWhatShouldntBeRenamed(): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/util/renaming/fileRenamer.js

@@ -0,0 +1,120 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import ManifestRenamingHandler from "./handlers/manifestRenamingHandler.js";
+import { stringToBuffer, bufferToString, bufferToJson, jsonToBuffer } from "../commonUtil.js";
+import { getSAPUI5DependencyIds } from "../manifestUtil.js";
+import { renameMap } from "./referenceRenaming.js";
+import { TEXT_EXTENSIONS } from "../resourceUtil.js";
+import { posix as path } from "path";
+function isTextFile(filename) {
+    return TEXT_EXTENSIONS.has(path.extname(filename).slice(1));
+}
+function getManifestSAPUI5DependencyIds(files) {
+    const manifestFile = files.get("manifest.json");
+    return manifestFile ? getSAPUI5DependencyIds(bufferToJson(manifestFile)) : [];
+}
+function getI18nPropertyKeys(files) {
+    const keys = new Set();
+    files.forEach((content, filename) => {
+        if (filename.endsWith(".properties")) {
+            const lines = bufferToString(content).split("\n").filter(line => !line.startsWith("#"));
+            for (const line of lines) {
+                const [key] = line.split("=");
+                if (key) {
+                    keys.add(key);
+                }
+            }
+        }
+    });
+    return [...keys];
+}
+/**
+ * Renames references (old id → adaptation project id) across all text files in
+ * place, leaving i18n .properties files, their keys and SAPUI5 dependency ids
+ * untouched.
+ */
+export default class FileRenamer {
+    /**
+     * 1p. i18n.properties are not renamed and property keys are ignored during
+     * the renaming across the files. Stateless: does not use `this`.
+     * @param files - all files both base and appVariants
+     * @param references - Reference maps of the app variant
+     */
+    static rename(files, references) {
+        const IGNORE_EXTENSIONS = [".properties"];
+        const ignoreInString = [
+            ...getI18nPropertyKeys(files),
+            ...getManifestSAPUI5DependencyIds(files)
+        ];
+        const updates = new Map();
+        for (const [filename, content] of files) {
+            if (!isTextFile(filename)) {
+                continue;
+            }
+            if (!IGNORE_EXTENSIONS.some(ext => filename.endsWith(ext))) {
+                // 5p. We pass replacements as ignores since we don't want to
+                // rename them again. E.g. we replace app.id with
+                // customer.app.id, but if we found customer.app.id somewhere,
+                // because we applied changes or something, we don't want to
+                // rename it again to customer.customer.app.id.
+                const renamed = renameMap(bufferToString(content), references, [...references.values(), ...ignoreInString]);
+                updates.set(filename, stringToBuffer(renamed));
+            }
+        }
+        for (const [filename, content] of updates) {
+            files.set(filename, content);
+        }
+    }
+}
+__decorate([
+    restoreWhatShouldntBeRenamed()
+], FileRenamer, "rename", null);
+/**
+ * Snapshots the JSON paths that must survive renaming (e.g.
+ * sap.ui5/appVariantIdHierarchy, dependencies), runs the decorated method, then
+ * restores them. The decorated method receives a Map of files (filename →
+ * Buffer): every file a handler `accept`s is parsed, snapshotted before the
+ * renaming and restored + written back after. Each matching file gets its own
+ * handler instance so one file's snapshot can't clobber another's.
+ */
+export function restoreWhatShouldntBeRenamed() {
+    return function (_target, _propertyKey, descriptor) {
+        const handlerFactories = [() => new ManifestRenamingHandler()];
+        const originalValue = descriptor.value;
+        descriptor.value = function (...args) {
+            const files = args[0];
+            // Snapshot the protected paths with a dedicated handler instance per
+            // file, so one file's snapshot can't clobber another's. Multiple
+            // files can match a handler (e.g. the root manifest.json and a
+            // nested cards/.../manifest.json both end with "manifest.json"); a
+            // shared handler would let the last-snapshotted file (which may lack
+            // appVariantIdHierarchy) wipe the root manifest's value on restore.
+            const snapshots = [];
+            for (const [filename, content] of files) {
+                for (const createHandler of handlerFactories) {
+                    const handler = createHandler();
+                    if (handler.accept(filename)) {
+                        handler.snapshot(bufferToJson(content));
+                        snapshots.push({ filename, handler });
+                    }
+                }
+            }
+            originalValue.apply(this, args);
+            for (const { filename, handler } of snapshots) {
+                const content = files.get(filename);
+                if (content) {
+                    const json = bufferToJson(content);
+                    handler.restore(json);
+                    files.set(filename, jsonToBuffer(json));
+                }
+            }
+            return files;
+        };
+    };
+}
+;
+//# sourceMappingURL=fileRenamer.js.map

package/dist/util/{renamingHandlers → renaming/handlers}/jsonRenamingHandler.d.ts

@@ -3,8 +3,6 @@ export default abstract class JsonRenamingHandler {
     protected abstract filePath: string;
     protected abstract jsonPathsToRestore: string[];
     accept(filename: string): boolean;
-    before(json: any): void;
-    after(json: any): void;
     snapshot(json: any): void;
     restore(obj: any): void;
     protected store(obj: any, path: string): void;

package/dist/util/{renamingHandlers → renaming/handlers}/jsonRenamingHandler.js

@@ -3,12 +3,6 @@ export default class JsonRenamingHandler {
     accept(filename) {
         return filename.endsWith(this.filePath);
     }
-    before(json) {
-        this.jsonPathsToRestore.forEach(path => this.store(json, path));
-    }
-    after(json) {
-        this.restore(json);
-    }
     snapshot(json) {
         this.jsonPathsToRestore.forEach(path => this.store(json, path));
     }

package/dist/util/{renamingUtil.d.ts → renaming/referenceRenaming.d.ts}

@@ -1,20 +1,20 @@
 export declare function rename(content: string, references: string[], replacement: string): string;
 /**
- * A precompiled renamer: the regex, replacement lookup and ignore set are built
+ * A precompiled replacer: the regex, replacement lookup and ignore set are built
  * once and can be applied to many strings via `replace` without recompilation.
  */
-export interface Renamer {
+export interface CompiledReplacer {
     replace(content: string): string;
 }
 /**
- * Builds a reusable {@link Renamer} from the given references and ignore list.
+ * Builds a reusable {@link CompiledReplacer} from the given references and ignore list.
  * The expensive work (regex compilation, lookup construction) happens here once;
  * the returned `replace` is a cheap single pass over each input string. Prefer
  * this over calling {@link renameMap} repeatedly with the same references.
  *
  * Note: mutates `references` by dropping entries whose dot-count doesn't match.
  */
-export declare function compileRenamer(references: Map<string, string>, ignoreInStrings: string[]): Renamer;
+export declare function compileReplacer(references: Map<string, string>, ignoreInStrings: string[]): CompiledReplacer;
 export declare function renameMap(content: string, references: Map<string, string>, ignoreInStrings: string[]): string;
 export declare function renameJson(json: Record<string, unknown>, references: Map<string, string>, ignoreInStrings: string[]): void;
 export declare function renameResources(files: ReadonlyMap<string, string>, search: string[], replacement: string): Map<string, string>;

package/dist/util/{renamingUtil.js → renaming/referenceRenaming.js}

@@ -1,19 +1,19 @@
 import { getLogger } from "@ui5/logger";
-const log = getLogger("@ui5/task-adaptation::RenamingUtil");
+const log = getLogger("@ui5/task-adaptation::ReferenceRenaming");
 const dotToSlash = (string) => string.replaceAll(".", "/");
 const escapeRegex = (string) => string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 export function rename(content, references, replacement) {
     return renameMap(content, new Map(references.map(ref => [ref, replacement])), [replacement]);
 }
 /**
- * Builds a reusable {@link Renamer} from the given references and ignore list.
+ * Builds a reusable {@link CompiledReplacer} from the given references and ignore list.
  * The expensive work (regex compilation, lookup construction) happens here once;
  * the returned `replace` is a cheap single pass over each input string. Prefer
  * this over calling {@link renameMap} repeatedly with the same references.
  *
  * Note: mutates `references` by dropping entries whose dot-count doesn't match.
  */
-export function compileRenamer(references, ignoreInStrings) {
+export function compileReplacer(references, ignoreInStrings) {
     const ignoredReferenceKeys = [];
     for (const [key, value] of references) {
         if (value.includes(".") !== key.includes(".")) {
@@ -96,13 +96,13 @@ export function compileRenamer(references, ignoreInStrings) {
     };
 }
 export function renameMap(content, references, ignoreInStrings) {
-    return compileRenamer(references, ignoreInStrings).replace(content);
+    return compileReplacer(references, ignoreInStrings).replace(content);
 }
 export function renameJson(json, references, ignoreInStrings) {
-    const renamer = compileRenamer(references, ignoreInStrings);
+    const replacer = compileReplacer(references, ignoreInStrings);
     function processObject(obj) {
         for (const key of Object.keys(obj)) {
-            const renamedKey = renamer.replace(key);
+            const renamedKey = replacer.replace(key);
             const value = obj[key];
             if (renamedKey !== key) {
                 obj[renamedKey] = value;
@@ -115,7 +115,7 @@ export function renameJson(json, references, ignoreInStrings) {
         const target = container;
         const value = target[index];
         if (typeof value === "string") {
-            target[index] = renamer.replace(value);
+            target[index] = replacer.replace(value);
         }
         else if (Array.isArray(value)) {
             value.forEach((_, i) => processValue(value, i));
@@ -129,4 +129,4 @@ export function renameJson(json, references, ignoreInStrings) {
 export function renameResources(files, search, replacement) {
     return new Map([...files].map(([filepath, content]) => [filepath, rename(content, search, replacement)]));
 }
-//# sourceMappingURL=renamingUtil.js.map
+//# sourceMappingURL=referenceRenaming.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ui5/task-adaptation",
-    "version": "1.6.8",
+    "version": "1.7.0",
     "description": "Custom task for ui5-builder which allows building UI5 Flexibility Adaptation Projects for SAP BTP, Cloud Foundry environment",
     "main": "dist/index.js",
     "exports": {
@@ -10,8 +10,9 @@
         }
     },
     "scripts": {
-        "test": "npm run lint && npm run build && npm run coverage",
+        "test": "npm run lint && npm run build && npm run typecheck:test && npm run coverage",
         "lint": "eslint ./src ./test/lib",
+        "typecheck:test": "tsc -p ./test/lib/tsconfig.json --noEmit",
         "dev": "mocha --no-timeouts --no-warnings --import=tsx \"test/lib/**/*.spec.ts\"",
         "perf": "mocha --no-timeouts --no-warnings --import=tsx \"test/lib/**/*.perf.ts\"",
         "coverage": "c8 npm run dev",
@@ -132,4 +133,4 @@
         "@rollup/rollup-linux-x64-gnu": "^4.28.1",
         "@rollup/rollup-linux-x64-musl": "^4.28.1"
     }
-}
+}