@ui5/task-adaptation 1.5.1 → 1.5.2-rc.0

package/dist/util/cfUtil.js

@@ -81,6 +81,12 @@ export default class CFUtil {
             throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}: ${error}`);
         }
     }
+    static deleteServiceKeyUnsafe(serviceInstanceName, serviceKeyName) {
+        // Fire and forget - async delete without waiting for result or handling errors
+        this.cfExecute(["delete-service-key", serviceInstanceName, serviceKeyName, "-f"]).catch(() => {
+            // Ignore any errors - this is intentionally unsafe
+        });
+    }
     static async getServiceInstance(params) {
         const PARAM_MAP = {
             spaceGuids: "space_guids",
@@ -159,6 +165,121 @@ export default class CFUtil {
             throw new Error(`Failed parse response from request CF API: ${error.message}`);
         }
     }
+    /**
+     * Get service keys and return the first one with valid endpoints
+     * @private
+     * @static
+     * @param {string} serviceInstanceGuid the service instance guid
+     * @return {Promise<any>} the first service key with valid endpoints, or null if none found
+     * @memberof CFUtil
+     */
+    static async getServiceKeyWithValidEndpoints(serviceInstanceGuid) {
+        try {
+            const serviceKeys = await this.getServiceKeys(serviceInstanceGuid);
+            // Find and return the first key with valid endpoints
+            return serviceKeys.find((key) => key.credentials?.endpoints && this.hasValidEndpoints(key.credentials.endpoints));
+        }
+        catch (error) {
+            throw new Error("Failed to get service credentials: " + error.message);
+        }
+    }
+    /**
+     * Get service keys for a service instance by name. If the existing service key
+     * has endpoints as strings instead of objects, a new service key will be created.
+     * @static
+     * @param {string} serviceInstanceName name of the service instance
+     * @param {string} [spaceGuid] optional space guid, will use current space if not provided
+     * @return {Promise<any>} promise with service key credentials
+     * @memberof CFUtil
+     */
+    static async getOrCreateServiceKeyWithEndpoints(serviceInstanceName, spaceGuid) {
+        const resolvedSpaceGuid = await this.getSpaceGuid(spaceGuid);
+        // Find service instance by name
+        const serviceInstances = await this.getServiceInstance({
+            names: [serviceInstanceName],
+            spaceGuids: [resolvedSpaceGuid]
+        });
+        if (!(serviceInstances?.length > 0)) {
+            throw new Error(`Cannot find service instance '${serviceInstanceName}' in space: ${resolvedSpaceGuid}`);
+        }
+        const serviceInstance = serviceInstances[0];
+        log.verbose(`Found service instance '${serviceInstance.name}' with guid: ${serviceInstance.guid}`);
+        // If no valid service key found, create a new one with unique name
+        const uniqueServiceKeyNamePromise = this.generateUniqueServiceKeyName(serviceInstance.name, serviceInstance.guid);
+        // Get service keys with credentials to find any with valid endpoints:
+        // object with url and destination instead of a single url string
+        const validKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
+        if (validKey) {
+            log.verbose(`Using existing service key with valid endpoints structure`);
+            return validKey.credentials;
+        }
+        const uniqueServiceKeyName = await uniqueServiceKeyNamePromise;
+        log.info(`No valid service key found with proper endpoints structure. Creating new service key '${uniqueServiceKeyName}' for '${serviceInstance.name}'`);
+        await this.createServiceKey(serviceInstance.name, uniqueServiceKeyName);
+        // Get the newly created service key and validate its endpoints
+        const newValidKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
+        if (newValidKey) {
+            log.verbose(`Using newly created service key with valid endpoints structure`);
+            return newValidKey.credentials;
+        }
+        // Clean up the created service key since it doesn't have valid
+        // endpoints. We don't throw an error here even if no valid endpoints
+        // found. We assume that there might be no coincidence between
+        // credential endpoints and xs-app.json destinations.
+        this.deleteServiceKeyUnsafe(serviceInstance.name, uniqueServiceKeyName);
+        log.verbose(`Created service key '${uniqueServiceKeyName}' does not have valid endpoints structure. Triggered deletion of invalid service key '${uniqueServiceKeyName}'`);
+    }
+    /**
+     * Check if endpoints object has at least one property that is an object
+     * @private
+     * @static
+     * @param {any} endpoints the endpoints object to validate
+     * @return {boolean} true if at least one property of endpoints is an object
+     * @memberof CFUtil
+     */
+    static hasValidEndpoints(endpoints) {
+        if (!endpoints || typeof endpoints !== 'object' || Array.isArray(endpoints)) {
+            return false;
+        }
+        // Check if at least one property of endpoints is an object
+        return Object.values(endpoints).some(value => value && typeof value === 'object' && !Array.isArray(value));
+    }
+    /**
+     * Get all service key names for a service instance
+     * @private
+     * @static
+     * @param {string} serviceInstanceGuid the service instance guid
+     * @return {Promise<string[]>} promise with array of service key names
+     * @memberof CFUtil
+     */
+    static async getAllServiceKeyNames(serviceInstanceGuid) {
+        try {
+            const serviceKeys = await this.requestCfApi(`/v3/service_credential_bindings?type=key&service_instance_guids=${serviceInstanceGuid}`);
+            return serviceKeys.map((key) => key.name);
+        }
+        catch (error) {
+            throw new Error(`Failed to get service key names: ${error.message}`);
+        }
+    }
+    /**
+     * Generate a unique service key name in format serviceInstanceName-key-N
+     * @static
+     * @param {string} serviceInstanceName the service instance name
+     * @param {string} serviceInstanceGuid the service instance guid
+     * @return {Promise<string>} promise with unique service key name
+     * @memberof CFUtil
+     */
+    static async generateUniqueServiceKeyName(serviceInstanceName, serviceInstanceGuid) {
+        const existingKeyNames = await this.getAllServiceKeyNames(serviceInstanceGuid);
+        let counter = 0;
+        let keyName;
+        do {
+            keyName = `${serviceInstanceName}-key-${counter}`;
+            counter++;
+        } while (existingKeyNames.includes(keyName));
+        log.verbose(`Generated unique service key name: ${keyName}`);
+        return keyName;
+    }
     /**
      * Get space guid from configuration or local CF fodler
      * @static

package/dist/util/commonUtil.d.ts

@@ -3,8 +3,6 @@ import Language from "../model/language.js";
 export declare function dotToUnderscore(value: string): string;
 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 renameResources(files: ReadonlyMap<string, string>, search: string, replacement: string): Map<string, string>;
-export declare function rename(content: string, search: string, replacement: 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;
@@ -12,3 +10,4 @@ export declare function traverse(json: any, paths: string[], callback: (json: an
 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: string): boolean;

package/dist/util/commonUtil.js

@@ -4,6 +4,8 @@ import { fileURLToPath } from "url";
 import { posix as path } from "path";
 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 dotToUnderscore(value) {
     return value.replace(/\./g, "_");
 }
@@ -17,46 +19,6 @@ export function validateObject(options, properties, message) {
 export function escapeRegex(update) {
     return update.replaceAll(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
 }
-export function renameResources(files, search, replacement) {
-    const replaces = getReplaceRegex(search, replacement);
-    const renamedFiles = new Map();
-    files.forEach((content, filepath) => {
-        renamedFiles.set(filepath, replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content));
-    });
-    return renamedFiles;
-}
-function getReplaceRegex(search, replacement) {
-    // The current regex works if the old Id is contained in the new Id, given
-    // that they do not have the same beginning.
-    // more complete alternative: /((?<!newIdStart)|(?!newIdEnd))oldId/g
-    let escapedSearch;
-    if (replacement.includes(search)) {
-        const [before] = replacement.split(search);
-        // Matches a position in the string that is not immediately preceded by
-        // the string "before". Since we won't replace anyway, we should also
-        // ignore one with the slashes.
-        const escapedBefore = escapeRegex(before).replaceAll("\\.", "[\\./]");
-        escapedSearch = `(?<!${escapedBefore})${escapeRegex(search)}`;
-    }
-    else {
-        escapedSearch = escapeRegex(search);
-    }
-    const dotToSlash = (update) => update.replaceAll(".", "\/");
-    return [
-        {
-            regexp: new RegExp(escapedSearch, "g"),
-            replacement
-        },
-        {
-            regexp: new RegExp(dotToSlash(escapedSearch), "g"),
-            replacement: dotToSlash(replacement)
-        }
-    ];
-}
-export function rename(content, search, replacement) {
-    const replaces = getReplaceRegex(search, replacement);
-    return replaces.reduce((p, c) => p.replace(c.regexp, c.replacement), content);
-}
 export function insertInArray(array, index, insert) {
     array.splice(index, 0, insert);
 }
@@ -126,4 +88,11 @@ export function getUniqueName(existingNames, template) {
     } while (existingNames.includes(template + suffixString));
     return template + suffixString;
 }
+export function isManifestChange(filename, content) {
+    if (filename.endsWith(CHANGES_EXT)) {
+        const change = JSON.parse(content);
+        return change.changeType?.startsWith(MANIFEST_CHANGE);
+    }
+    return false;
+}
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/filesUtil.d.ts

@@ -0,0 +1,16 @@
+export default class FilesUtil {
+    static filter(files: ReadonlyMap<string, string>): ReadonlyMap<string, string>;
+    /**
+     * 1p. i18n.properties are not renamed and property keys are ignored during
+     * the renaming across the files.
+     * @param files - all files both base and appVariants
+     * @param references - Reference maps of the app variant
+     * @returns A map of renamed files
+     */
+    static rename(files: ReadonlyMap<string, string>, references: Map<string, string>): ReadonlyMap<string, string>;
+    private static getI18nPropertyKeys;
+}
+/**
+ * We might rename appVariantIdHierarchy, so we restore it after the renaming.
+ */
+export declare function restoreThatShouldntBeRenamed(): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/util/filesUtil.js

@@ -0,0 +1,83 @@
+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 { renameMap } from "./renamingUtil.js";
+import ManifestRenamingHandler from "./renamingHandlers/manifestRenamingHandler.js";
+export default class FilesUtil {
+    static filter(files) {
+        const shouldIgnore = (filename, content) => {
+            const IGNORE_FILES = ["manifest.appdescr_variant"];
+            if (filename.endsWith(".change")) {
+                return JSON.parse(content).changeType?.startsWith("appdescr_"); // validate JSON
+            }
+            return IGNORE_FILES.includes(filename);
+        };
+        const result = new Map();
+        files.forEach((content, filename) => {
+            if (!shouldIgnore(filename, content)) {
+                result.set(filename, content);
+            }
+        });
+        return result;
+    }
+    /**
+     * 1p. i18n.properties are not renamed and property keys are ignored during
+     * the renaming across the files.
+     * @param files - all files both base and appVariants
+     * @param references - Reference maps of the app variant
+     * @returns A map of renamed files
+     */
+    static rename(files, references) {
+        const IGNORE_EXTENSIONS = [".properties"];
+        const ignoreInString = this.getI18nPropertyKeys(files);
+        return new Map(Array.from(files, ([filename, content]) => {
+            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.
+                content = renameMap(content, references, [...references.values(), ...ignoreInString]);
+            }
+            return [filename, content];
+        }));
+    }
+    static getI18nPropertyKeys(files) {
+        const keys = new Set();
+        files.forEach((content, filename) => {
+            if (filename.endsWith(".properties")) {
+                const lines = content.split("\n").filter(line => !line.startsWith("#"));
+                for (const line of lines) {
+                    const [key] = line.split("=");
+                    if (key) {
+                        keys.add(key);
+                    }
+                }
+            }
+        });
+        return [...keys];
+    }
+}
+__decorate([
+    restoreThatShouldntBeRenamed()
+], FilesUtil, "rename", null);
+/**
+ * We might rename appVariantIdHierarchy, so we restore it after the renaming.
+ */
+export function restoreThatShouldntBeRenamed() {
+    return function (_target, _propertyKey, descriptor) {
+        const handlers = [new ManifestRenamingHandler()];
+        const originalValue = descriptor.value;
+        descriptor.value = function (...args) {
+            handlers.forEach(handler => handler.before(args[0]));
+            const renamedFiles = originalValue.apply(this, args);
+            handlers.forEach(handler => handler.after(renamedFiles));
+            return renamedFiles;
+        };
+    };
+}
+;
+//# sourceMappingURL=filesUtil.js.map

package/dist/util/i18nMerger.js

@@ -1,4 +1,4 @@
-import { dotToUnderscore, escapeRegex, trimExtension } from "./commonUtil.js";
+import { escapeRegex, trimExtension } from "./commonUtil.js";
 import { posix as path } from "path";
 export default class FileMerger {
     static analyzeAppVariantManifestChanges(manifestChanges) {
@@ -24,7 +24,7 @@ export default class FileMerger {
         return { mergePaths: Array.from(mergePaths), copyPaths: Array.from(copyPaths) };
     }
     static merge(baseAppFiles, i18nPath, appVariant) {
-        const i18nTargetFolder = dotToUnderscore(appVariant.id);
+        const i18nTargetFolder = appVariant.prefix;
         const { copyPaths, mergePaths } = this.analyzeAppVariantManifestChanges(appVariant.getProcessedManifestChanges());
         const files = new Map(baseAppFiles);
         for (const [filename, content] of Array.from(appVariant.getProcessedFiles())) {

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

@@ -0,0 +1,8 @@
+export declare const moveFiles: (inputFiles: ReadonlyMap<string, string>, prefix: string, id: string) => {
+    files: Map<string, string>;
+    renamingPaths: Map<string, string>;
+};
+export declare const moveFile: (filename: string, content: string, prefix: string, id: string) => {
+    newFilename: string;
+    renamingPath: Map<string, string>;
+};

package/dist/util/movingHandler/fileMoveHandler.js

@@ -0,0 +1,77 @@
+import path from "path";
+import { isManifestChange } from "../commonUtil.js";
+const EXT_DIR = "ext/";
+const CHANGES_DIR = "changes/";
+const nameSpaceRegex = new RegExp(`(?<=ControllerExtension.extend\\(")([^"]*)(?=")`);
+/**
+* 2p. We move to appVariantFolder (prefix) only files that go along the
+* change files, like js or fragments. Changes are renamed in resources,
+* packed in flexibility-bundle and removed.
+* @param filename - The filename relative to the root
+*/
+function shouldMove(filename, content) {
+    //TODO: is it more reliable to check change/fileType?
+    if (isManifestChange(filename, content)) {
+        return true;
+    }
+    return filename.startsWith(CHANGES_DIR) && [".change", ".variant", ".ctrl_variant", ".ctrl_variant_change", ".ctrl_variant_management_change"].every(ext => !filename.endsWith(ext))
+        || filename.startsWith(EXT_DIR);
+}
+/**
+ * For controller extension the namespace needs a prefix
+ * The namespace needs to be unique for clear identification
+ * If controller extension have the same namespace the last one will be used
+ * @param filename  - The filename relative to the root
+ * @returns
+ */
+function shouldNamespaceRenamed(filename) {
+    return filename.startsWith(CHANGES_DIR) && filename.endsWith(".js");
+}
+/**
+ * Returns path without first directory (which is usually "changes" or
+ * "ext") and without file extension. For example, for
+ * "changes/coding/FixingDay.js" it returns "coding/FixingDay", for
+ * "changes/customer_app_variant5/fragments/hello_world_fixing_day.fragment.xml"
+ * it returns
+ * "changes/customer_app_variant5/fragments/hello_world_fixing_day". We
+ * remove all extensions not to rename it with slashes instead of dots. And
+ * we also exclude "changes" or "ext" include the prefix after them and then
+ * the filename. Without 'changes' or 'ext' directory, we need to replace
+ * only rest: coding/FixingDay.js to app_var_id1/coding/FixingDay.js
+ * @param filename
+ * @returns
+ */
+function getPathWithoutExtensions(filename) {
+    const [_dir, ...rest] = filename.split("/");
+    const restWOExt = [...rest];
+    restWOExt[restWOExt.length - 1] = restWOExt[restWOExt.length - 1].split(".")[0];
+    return restWOExt.join("/");
+}
+export const moveFiles = (inputFiles, prefix, id) => {
+    const files = new Map();
+    let renamingPaths = new Map();
+    inputFiles.forEach((content, filename) => {
+        const { newFilename, renamingPath } = moveFile(filename, content, prefix, id);
+        files.set(newFilename, content);
+        renamingPaths = new Map([...renamingPaths, ...renamingPath]);
+    });
+    return { files, renamingPaths };
+};
+export const moveFile = (filename, content, prefix, id) => {
+    let newFilename = filename;
+    let renamingPath = new Map();
+    if (shouldMove(filename, content)) {
+        const [dir, ...rest] = filename.split("/");
+        newFilename = path.join(dir, prefix, rest.join("/"));
+        const restWOExtPath = getPathWithoutExtensions(filename);
+        renamingPath.set(restWOExtPath, path.join(prefix, restWOExtPath));
+    }
+    if (shouldNamespaceRenamed(filename)) {
+        const namespaceMatch = nameSpaceRegex.exec(content.trim());
+        const controllerExtensionPath = namespaceMatch ? namespaceMatch[0] : "";
+        const fileName = controllerExtensionPath.replace(id, "");
+        renamingPath.set(controllerExtensionPath, `${id}.${prefix}${fileName}`);
+    }
+    return { newFilename, renamingPath };
+};
+//# sourceMappingURL=fileMoveHandler.js.map

package/dist/util/renamingHandlers/manifestRenamingHandler.d.ts

@@ -0,0 +1,6 @@
+import { IRenamingHandler } from "./renamingHandler.js";
+export default class ManifestRenamingHandler implements IRenamingHandler {
+    private appVariantIdHierarchy;
+    before(files: ReadonlyMap<string, string>): void;
+    after(files: Map<string, string>): void;
+}

package/dist/util/renamingHandlers/manifestRenamingHandler.js

@@ -0,0 +1,20 @@
+export default class ManifestRenamingHandler {
+    appVariantIdHierarchy = [];
+    before(files) {
+        const manifest = files.get("manifest.json");
+        if (manifest) {
+            const manifestJson = JSON.parse(manifest);
+            this.appVariantIdHierarchy = manifestJson["sap.ui5"].appVariantIdHierarchy;
+        }
+    }
+    after(files) {
+        const manifest = files.get("manifest.json");
+        if (manifest) {
+            const manifestJson = JSON.parse(manifest);
+            manifestJson["sap.ui5"].appVariantIdHierarchy = this.appVariantIdHierarchy;
+            files.set("manifest.json", JSON.stringify(manifestJson));
+        }
+    }
+    ;
+}
+//# sourceMappingURL=manifestRenamingHandler.js.map

package/dist/util/renamingHandlers/renamingHandler.d.ts

@@ -0,0 +1,4 @@
+export interface IRenamingHandler {
+    before(files: ReadonlyMap<string, string>): void;
+    after(files: Map<string, string>): void;
+}

package/dist/util/renamingHandlers/renamingHandler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=renamingHandler.js.map

package/dist/util/renamingUtil.d.ts

@@ -0,0 +1,3 @@
+export declare function rename(content: string, references: string[], replacement: string): string;
+export declare function renameMap(content: string, references: Map<string, string>, ignoreInStrings: string[]): string;
+export declare function renameResources(files: ReadonlyMap<string, string>, search: string[], replacement: string): Map<string, string>;

package/dist/util/renamingUtil.js

@@ -0,0 +1,111 @@
+import { getLogger } from "@ui5/logger";
+const log = getLogger("@ui5/task-adaptation::RenamingUtil");
+export function rename(content, references, replacement) {
+    return renameMap(content, new Map(references.map(ref => [ref, replacement])), [replacement]);
+}
+export function renameMap(content, references, ignoreInStrings) {
+    const ignoredReferenceKeys = [];
+    for (const [key, value] of references) {
+        if (value.includes(".") !== key.includes(".")) {
+            ignoredReferenceKeys.push(key);
+            references.delete(key);
+        }
+    }
+    if (ignoredReferenceKeys.length > 0) {
+        log.info(`Ignored renaming: ${ignoredReferenceKeys.join(", ")}`);
+    }
+    const searchTerms = [...references.keys()];
+    if (!content || !searchTerms || searchTerms.length === 0) {
+        return content;
+    }
+    const dotToSlash = (str) => str.replaceAll(".", "\/");
+    // We don't want to replace in adaptation project ids
+    ignoreInStrings.push(...ignoreInStrings, ...ignoreInStrings.map(dotToSlash));
+    let start = 0;
+    while (true) {
+        // If we don't replace some strings in the content - we find all of them
+        // and then don't replace inside their start and end indices.
+        const ignoredStrings = ignoreInStrings.map(string => {
+            return findAllOccurrences(content, string, start).map(i => ({ start: i, end: i + string.length }));
+        }).filter(arr => arr.length > 0) || [];
+        // We find the next search index with dots and slashes. Then we replace
+        // the nearest one and start search again in the next loop step.
+        const indices = new Array();
+        for (const searchTerm of searchTerms) {
+            const searchTermSlash = dotToSlash(searchTerm);
+            indices.push({
+                i: content.indexOf(searchTerm, start),
+                replacement: references.get(searchTerm),
+                searchTerm
+            }, {
+                i: content.indexOf(searchTermSlash, start),
+                replacement: dotToSlash(references.get(searchTerm)),
+                searchTerm: searchTermSlash
+            });
+        }
+        const found = indices.filter(({ i }) => i > -1);
+        if (found.length === 0) {
+            return content;
+        }
+        const inBetween = (intervals, i) => {
+            for (const interval of intervals) {
+                for (const { start, end } of interval) {
+                    if (i >= start && i <= end) {
+                        return { start, end };
+                    }
+                }
+            }
+        };
+        // If we found two strings with the same index, we take the longest one
+        // to replace, e.g.: app.variant and app.variant2 has the same index,
+        // but we don't want to replace the first one with customer.app.variant,
+        // otherwise we get customer.app.variant2, which we don't need. We need
+        // to replace the whole app.variant2 with customer.app.variant. 
+        const findCurrentReplace = (found) => {
+            const result = new Map();
+            for (const entry of found) {
+                const existing = result.get(entry.i);
+                if (!existing || entry.searchTerm.length >= existing.searchTerm.length) {
+                    result.set(entry.i, entry);
+                }
+            }
+            return [...result.values()].sort((a, b) => a.i - b.i)[0];
+        };
+        // Ignore if search is in i18n key: replace "id" in "{{id.key}}" with
+        // "customer.id" and we need only the next one in string
+        found.forEach(index => index.inBetween = inBetween(ignoredStrings, index.i));
+        // There might be a situation when we found something in ignored
+        // substrings and the index could be the nearest, but after that the
+        // next index might be the actual find to replace, so we first of all
+        // ignore all the ignored substring findings and get the next actual
+        // replacement. But if there are only ignored substrings found, we take
+        // the first one just to skip it and go further.
+        const currentReplace = findCurrentReplace(found);
+        if (currentReplace.inBetween) {
+            start = currentReplace.inBetween.end;
+        }
+        else {
+            content = content.substring(0, currentReplace.i)
+                + currentReplace.replacement
+                + content.substring(currentReplace.i + currentReplace.searchTerm.length);
+            start = currentReplace.i + currentReplace.replacement.length;
+        }
+    }
+}
+export function renameResources(files, search, replacement) {
+    return new Map([...files].map(([filepath, content]) => [filepath, rename(content, search, replacement)]));
+}
+function findAllOccurrences(string, substring, start) {
+    if (!substring) {
+        return [];
+    }
+    const indices = [];
+    let index = start;
+    while ((index = string.indexOf(substring, index)) !== -1) {
+        indices.push(index);
+        index += substring.length; // shift from current finding
+    }
+    return indices;
+}
+;
+//# sourceMappingURL=renamingUtil.js.map