@ui5/task-adaptation 1.6.6 → 1.6.8

package/dist/util/movingHandler/changeFileMoveHandler.js

@@ -1,4 +1,4 @@
-import { isManifestChange } from "../commonUtil.js";
+import { bufferToString, isManifestChange } from "../commonUtil.js";
 const EXT_DIR = "ext/";
 const CHANGES_DIR = "changes/";
 const nameSpaceRegex = new RegExp(`(?<=ControllerExtension.extend\\(")([^"]*)(?=")`);
@@ -21,7 +21,7 @@ function shouldMove(filename, content) {
  * 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
+ * @returns `true` if the file's namespace should be renamed, `false` otherwise
  */
 function shouldNamespaceRenamed(filename) {
     return filename.startsWith(CHANGES_DIR) && filename.endsWith(".js");
@@ -38,7 +38,8 @@ function shouldNamespaceRenamed(filename) {
  * 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
+ * @returns The path with the leading directory and all file extensions removed,
+ * e.g. `"changes/coding/FixingDay.js"` → `"coding/FixingDay"`
  */
 function getPathWithoutExtensions(filename) {
     const [_dir, ...rest] = filename.split("/");
@@ -66,7 +67,7 @@ export const moveFile = (filename, content, prefix, id) => {
         renamingPath.set(restWOExtPath, [prefix, restWOExtPath].join("/"));
     }
     if (shouldNamespaceRenamed(filename)) {
-        const namespaceMatch = nameSpaceRegex.exec(content.trim());
+        const namespaceMatch = nameSpaceRegex.exec(bufferToString(content).trim());
         const controllerExtensionPath = namespaceMatch ? namespaceMatch[0] : "";
         const fileName = controllerExtensionPath.replace(id, "");
         renamingPath.set(controllerExtensionPath, `${id}.${prefix}${fileName}`);

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

@@ -1,12 +1,13 @@
-import { IRenamingHandler } from "./renamingHandler.js";
-export default abstract class JsonRenamingHandler implements IRenamingHandler {
+export default abstract class JsonRenamingHandler {
     private original;
     protected abstract filePath: string;
     protected abstract jsonPathsToRestore: string[];
-    before(files: ReadonlyMap<string, string>): void;
-    after(files: Map<string, string>): void;
+    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;
-    protected restore(obj: any): void;
     private getByPath;
     private setByPath;
 }

package/dist/util/renamingHandlers/jsonRenamingHandler.js

@@ -1,26 +1,26 @@
 export default class JsonRenamingHandler {
     original = new Map();
-    before(files) {
-        const content = files.get(this.filePath);
-        if (content) {
-            const json = JSON.parse(content);
-            this.jsonPathsToRestore.forEach(path => this.store(json, path));
-        }
+    accept(filename) {
+        return filename.endsWith(this.filePath);
     }
-    after(files) {
-        const content = files.get(this.filePath);
-        if (content) {
-            const json = JSON.parse(content);
-            this.restore(json);
-            files.set(this.filePath, JSON.stringify(json));
-        }
+    before(json) {
+        this.jsonPathsToRestore.forEach(path => this.store(json, path));
     }
-    store(obj, path) {
-        this.original.set(path, this.getByPath(obj, path.split("/")));
+    after(json) {
+        this.restore(json);
+    }
+    snapshot(json) {
+        this.jsonPathsToRestore.forEach(path => this.store(json, path));
     }
     restore(obj) {
         this.original.forEach((value, path) => this.setByPath(obj, value, path.split("/")));
     }
+    store(obj, path) {
+        // Clone so the snapshot is decoupled from `obj`: when the same object is
+        // mutated in-place (JSON renaming), the stored value stays untouched.
+        const value = this.getByPath(obj, path.split("/"));
+        this.original.set(path, value === undefined ? undefined : structuredClone(value));
+    }
     getByPath(obj, path) {
         return path.reduce((o, p) => (o && o[p]) || undefined, obj);
     }

package/dist/util/renamingUtil.d.ts

@@ -1,3 +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
+ * once and can be applied to many strings via `replace` without recompilation.
+ */
+export interface Renamer {
+    replace(content: string): string;
+}
+/**
+ * Builds a reusable {@link Renamer} 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 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

@@ -1,12 +1,23 @@
 import { getLogger } from "@ui5/logger";
 const log = getLogger("@ui5/task-adaptation::RenamingUtil");
+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]);
 }
-export function renameMap(content, references, ignoreInStrings) {
+/**
+ * Builds a reusable {@link Renamer} 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) {
     const ignoredReferenceKeys = [];
     for (const [key, value] of references) {
         if (value.includes(".") !== key.includes(".")) {
+            log.info(`Ignoring renaming of "${key}" → "${value}" because the dot count does not match.`);
             ignoredReferenceKeys.push(key);
             references.delete(key);
         }
@@ -15,97 +26,107 @@ export function renameMap(content, references, ignoreInStrings) {
         log.info(`Ignored renaming: ${ignoredReferenceKeys.join(", ")}`);
     }
     const searchTerms = [...references.keys()].filter(key => key.length > 0);
-    if (!content || !searchTerms || searchTerms.length === 0) {
-        return content;
+    if (searchTerms.length === 0) {
+        return {
+            replace: (content) => 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
-            });
+    // Build replacement lookup: pattern → replacement string (both dot and slash variants).
+    const replacementMap = new Map();
+    for (const term of searchTerms) {
+        const replacement = references.get(term);
+        replacementMap.set(term, replacement);
+        const slashTerm = dotToSlash(term);
+        if (slashTerm !== term) {
+            replacementMap.set(slashTerm, dotToSlash(replacement));
         }
-        const found = indices.filter(({ i }) => i > -1);
-        if (found.length === 0) {
-            return content;
+    }
+    // Build deduplicated ignore set with slash variants
+    const ignoreSet = new Set();
+    for (const ignoredString of ignoreInStrings) {
+        if (ignoredString) {
+            ignoreSet.add(ignoredString);
+            ignoreSet.add(dotToSlash(ignoredString));
         }
-        const inBetween = (intervals, i) => {
-            for (const interval of intervals) {
-                for (const { start, end } of interval) {
-                    if (i >= start && i <= end) {
-                        return { start, end };
-                    }
-                }
+    }
+    // When a string appears in both replacementMap and ignoreSet, ignoreSet
+    // takes precedence — the match is skipped rather than replaced. Remove such
+    // keys from replacementMap so the intent is explicit instead of relying on
+    // runtime check order.
+    for (const ignored of ignoreSet) {
+        replacementMap.delete(ignored);
+    }
+    // Collect all unique patterns sorted by length descending (longest match first).
+    // V8 compiles alternation of literal strings into an Aho-Corasick automaton
+    // internally, giving us O(n + P + z) single-pass matching in native C++ code.
+    const allPatterns = new Set([...replacementMap.keys(), ...ignoreSet]);
+    const sorted = [...allPatterns].sort((a, b) => b.length - a.length);
+    // Reused across `replace` calls; `lastIndex` is reset at the start of each run.
+    const regex = new RegExp(sorted.map(escapeRegex).join("|"), "g");
+    return {
+        replace(content) {
+            if (!content) {
+                return content;
             }
-        };
-        // 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);
+            regex.lastIndex = 0;
+            // Single-pass: find all matches, skip ignored ones, batch-replace the rest
+            const parts = [];
+            let lastEnd = 0;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const matched = match[0];
+                if (ignoreSet.has(matched)) {
+                    // ignore takes priority over replacement
+                    continue;
+                }
+                const replacement = replacementMap.get(matched);
+                if (replacement !== undefined) {
+                    parts.push(content.substring(lastEnd, match.index));
+                    parts.push(replacement);
+                    lastEnd = match.index + matched.length;
                 }
             }
-            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;
+            // Nothing matched: return the original string without allocating a join.
+            if (lastEnd === 0) {
+                return content;
+            }
+            parts.push(content.substring(lastEnd));
+            return parts.join("");
         }
-        else {
-            content = content.substring(0, currentReplace.i)
-                + currentReplace.replacement
-                + content.substring(currentReplace.i + currentReplace.searchTerm.length);
-            start = currentReplace.i + currentReplace.replacement.length;
+    };
+}
+export function renameMap(content, references, ignoreInStrings) {
+    return compileRenamer(references, ignoreInStrings).replace(content);
+}
+export function renameJson(json, references, ignoreInStrings) {
+    const renamer = compileRenamer(references, ignoreInStrings);
+    function processObject(obj) {
+        for (const key of Object.keys(obj)) {
+            const renamedKey = renamer.replace(key);
+            const value = obj[key];
+            if (renamedKey !== key) {
+                obj[renamedKey] = value;
+                delete obj[key];
+            }
+            processValue(obj, renamedKey);
+        }
+    }
+    function processValue(container, index) {
+        const target = container;
+        const value = target[index];
+        if (typeof value === "string") {
+            target[index] = renamer.replace(value);
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((_, i) => processValue(value, i));
+        }
+        else if (value !== null && typeof value === "object") {
+            processObject(value);
         }
     }
+    processObject(json);
 }
 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

package/dist/util/resourceUtil.d.ts

@@ -1,14 +1,23 @@
+/**
+ * Extensions of files whose contents are processed by the adaptation
+ * pipeline as text. Anything outside this whitelist is treated as binary
+ * (e.g. images, fonts) and is saved to the workspace verbatim by WorkspaceManager.
+ *
+ * Kept in sync with EXTENSIONS_TO_PROCESS in appVariant.ts.
+ */
+export declare const TEXT_EXTENSIONS: ReadonlySet<string>;
 export default class ResourceUtil {
     static getRootFolder(projectNamespace?: string): string;
     static relativeToRoot(resourcePath: string, projectNamespace?: string): string;
     static getResourcePath(projectNamespace?: string, ...paths: string[]): string;
-    static write(dir: string, files: Map<string, string>): Promise<void[]>;
-    static writeInProject(dir: string, files: Map<string, string>): Promise<void[]>;
-    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, string>>;
-    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, string>>;
+    static write(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static writeInProject(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
+    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
     static getString(resource: any): Promise<string>;
     static getJson(resource: any): Promise<any>;
     static setString(resource: any, str: string): void;
-    static createResource(filename: string, projectNamespace: string, content: string): any;
-    static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace?: string): Promise<Map<string, string>>;
+    static createResource(filename: string, projectNamespace: string, content: string | Buffer): any;
+    private static createResourceFromContent;
+    static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace?: string): Promise<Map<string, Buffer>>;
 }

package/dist/util/resourceUtil.js

@@ -1,6 +1,31 @@
 import * as resourceFactory from "@ui5/fs/resourceFactory";
 import { posix as path } from "path";
 const UTF8 = "utf8";
+/**
+ * Extensions of files whose contents are processed by the adaptation
+ * pipeline as text. Anything outside this whitelist is treated as binary
+ * (e.g. images, fonts) and is saved to the workspace verbatim by WorkspaceManager.
+ *
+ * Kept in sync with EXTENSIONS_TO_PROCESS in appVariant.ts.
+ */
+export const TEXT_EXTENSIONS = new Set([
+    "js",
+    "json",
+    "xml",
+    "html",
+    "properties",
+    "change",
+    "appdescr_variant",
+    "ctrl_variant",
+    "ctrl_variant_change",
+    "ctrl_variant_management_change",
+    "annotation_change",
+    "variant",
+    "fioriversion",
+    "codeChange",
+    "xmlViewChange",
+    "context",
+]);
 export default class ResourceUtil {
     static getRootFolder(projectNamespace) {
         const newPath = ["/resources"];
@@ -21,7 +46,7 @@ export default class ResourceUtil {
      * NOTE: to write in project folder (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located), use writeInProject method.
      * @param dir The directory to write files to.
-     * @param files A Map of file paths and their contents.
+     * @param files A Map of file paths and their contents as Buffer.
      * @returns A promise that resolves when all files have been written.
      */
     static write(dir, files) {
@@ -30,8 +55,8 @@ export default class ResourceUtil {
             virBasePath: "/"
         });
         const promises = [];
-        files.forEach((string, filename) => {
-            const resource = resourceFactory.createResource({ path: "/" + filename, string });
+        files.forEach((content, filename) => {
+            const resource = ResourceUtil.createResourceFromContent("/" + filename, content);
             promises.push(fsTarget.write(resource));
         });
         return Promise.all(promises);
@@ -40,7 +65,7 @@ export default class ResourceUtil {
      * Write files to the project folder (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located), use writeInProject method.
      * @param dir The directory to write files to.
-     * @param files A Map of file paths and their contents.
+     * @param files A Map of file paths and their contents as Buffer.
      * @returns A promise that resolves when all files have been written.
      */
     static writeInProject(dir, files) {
@@ -53,22 +78,27 @@ export default class ResourceUtil {
      * @param dir The directory to search in.
      * @param pattern The glob pattern to match files, e.g., "/ui5AppInfo.json".
      * @param excludes An array of glob patterns to exclude from the search.
-     * @returns A promise that resolves to a Map of file paths and their contents.
+     * @returns A promise that resolves to a Map of file paths and their contents as Buffer.
      */
-    static byGlob(dir, pattern, excludes = []) {
+    static async byGlob(dir, pattern, excludes = []) {
         const adapter = resourceFactory.createAdapter({
             fsBasePath: dir,
             virBasePath: "/",
             excludes
         });
-        return adapter.byGlob(pattern).then((resources) => this.toFileMap(resources));
+        const resources = await adapter.byGlob(pattern);
+        const files = new Map();
+        for (const resource of resources) {
+            files.set(resource.getPath().substring(1), await resource.getBuffer());
+        }
+        return files;
     }
     /*
      * Search files in the adaptation project (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located), excluding specified glob patterns.
      * @param pattern The glob pattern to match files, e.g., "/ui5AppInfo.json".
      * @param excludes An array of glob patterns to exclude from the search.
-     * @returns A promise that resolves to a Map of file paths and their contents.
+     * @returns A promise that resolves to a Map of file paths and their contents as Buffer.
      */
     static byGlobInProject(pattern, excludes = []) {
         return ResourceUtil.byGlob("./", pattern, [
@@ -87,16 +117,22 @@ export default class ResourceUtil {
         resource.setBuffer(Buffer.from(str, UTF8));
     }
     static createResource(filename, projectNamespace, content) {
-        return resourceFactory.createResource({
-            path: this.getResourcePath(projectNamespace, filename),
-            string: content
-        });
+        return ResourceUtil.createResourceFromContent(this.getResourcePath(projectNamespace, filename), content);
+    }
+    static createResourceFromContent(resourcePath, content) {
+        return resourceFactory.createResource(Buffer.isBuffer(content)
+            ? { path: resourcePath, buffer: content }
+            : { path: resourcePath, string: content });
     }
     static async toFileMap(resources, projectNamespace) {
         const files = new Map();
-        const rootFolderLength = projectNamespace ? ResourceUtil.getRootFolder(projectNamespace).length : 0;
+        const rootFolder = projectNamespace ? ResourceUtil.getRootFolder(projectNamespace) : undefined;
         for (const resource of resources) {
-            files.set(resource.getPath().substring(rootFolderLength + 1), await ResourceUtil.getString(resource));
+            const resourcePath = resource.getPath();
+            const filename = rootFolder && resourcePath.startsWith(rootFolder)
+                ? resourcePath.substring(rootFolder.length + 1)
+                : resourcePath.substring(1);
+            files.set(filename, await resource.getBuffer());
         }
         return files;
     }

package/dist/util/validator/abapConnectionValidator.d.ts

@@ -0,0 +1,5 @@
+import { AbapTarget } from "@sap-ux/system-access";
+import { IAbapTargetMeta } from "../../model/configuration.js";
+export default class AbapConnectionValidator {
+    validateAndGetAbapTarget(target: AbapTarget & IAbapTargetMeta | undefined, destination: string | undefined): AbapTarget & IAbapTargetMeta;
+}

package/dist/util/validator/abapConnectionValidator.js

@@ -0,0 +1,22 @@
+import { validateObject } from "../commonUtil.js";
+import { isAppStudio } from "@sap-ux/btp-utils";
+import { getLogger } from "@ui5/logger";
+const log = getLogger("@ui5/task-adaptation::AbapConnectionValidator");
+export default class AbapConnectionValidator {
+    validateAndGetAbapTarget(target, destination) {
+        if (target) {
+            // if target configuration appears, we validate that it should be
+            // either target/destination for BAS or target/url for IDE we're
+            // trying to detect is it destination for BAS or url for IDE
+            const abapTargetProperties = isAppStudio() ? ["destination"] : ["url"];
+            validateObject(target, abapTargetProperties, "should be specified in ui5.yaml configuration/target");
+            return target;
+        }
+        else if (destination) {
+            log.warn("Destination is deprecated, use target/destination configuration instead");
+            return { destination };
+        }
+        throw new Error("Target should be specified in ui5.yaml configuration to connect the ABAP system");
+    }
+}
+//# sourceMappingURL=abapConnectionValidator.js.map

package/dist/util/validator/abapValidator.d.ts

@@ -1,8 +1,6 @@
-import { AbapTarget } from "@sap-ux/system-access";
-import { IAbapTargetMeta, IConfiguration, LandscapeType } from "../../model/configuration.js";
+import { IConfiguration, LandscapeType } from "../../model/configuration.js";
 import IValidator from "./validator.js";
 export default class AbapValidator implements IValidator {
     type: LandscapeType;
-    validateAndGetAbapTarget(target: AbapTarget & IAbapTargetMeta | undefined, destination: string | undefined): AbapTarget & IAbapTargetMeta;
-    validateConfiguration({ target, destination }: IConfiguration): void;
+    validateConfiguration({ destination, target }: IConfiguration): void;
 }

package/dist/util/validator/abapValidator.js

@@ -1,26 +1,14 @@
-import { validateObject } from "../commonUtil.js";
-import { isAppStudio } from "@sap-ux/btp-utils";
 import { getLogger } from "@ui5/logger";
 const log = getLogger("@ui5/task-adaptation::AbapValidator");
 export default class AbapValidator {
     type = "abap";
-    validateAndGetAbapTarget(target, destination) {
-        if (target) {
-            // if target configuration appears, we validate that it should be
-            // either target/destination for BAS or target/url for IDE we're
-            // trying to detect is it destination for BAS or url for IDE
-            const abapTargetProperties = isAppStudio() ? ["destination"] : ["url"];
-            validateObject(target, abapTargetProperties, "should be specified in ui5.yaml configuration/target");
-            return target;
+    validateConfiguration({ destination, target }) {
+        if (!destination && !target) {
+            throw new Error("'target' should be specified in ui5.yaml configuration");
         }
-        else if (destination) {
+        else if (destination && !target) {
             log.warn("Destination is deprecated, use target/destination configuration instead");
-            return { destination };
         }
-        throw new Error("Target should be specified in ui5.yaml configuration to connect the ABAP system");
-    }
-    validateConfiguration({ target, destination }) {
-        this.validateAndGetAbapTarget(target, destination);
     }
 }
 //# sourceMappingURL=abapValidator.js.map

package/dist/util/zipUtil.d.ts

@@ -1 +1 @@
-export declare function unzipZipEntries(zip: Buffer): Promise<Map<string, string>>;
+export declare function unzipZipEntries(zip: Buffer): Promise<Map<string, Buffer>>;

package/dist/util/zipUtil.js

@@ -11,6 +11,6 @@ export async function unzipZipEntries(zip) {
     }
 }
 function mapEntries(entries) {
-    return new Map(entries.filter(entry => !entry.isDirectory).map(entry => [entry.entryName, entry.getData().toString("utf8")]));
+    return new Map(entries.filter(entry => !entry.isDirectory).map(entry => [entry.entryName, entry.getData()]));
 }
 //# sourceMappingURL=zipUtil.js.map

package/package.json

@@ -1,8 +1,14 @@
 {
     "name": "@ui5/task-adaptation",
-    "version": "1.6.6",
+    "version": "1.6.8",
     "description": "Custom task for ui5-builder which allows building UI5 Flexibility Adaptation Projects for SAP BTP, Cloud Foundry environment",
-    "main": "index.js",
+    "main": "dist/index.js",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
     "scripts": {
         "test": "npm run lint && npm run build && npm run coverage",
         "lint": "eslint ./src ./test/lib",
@@ -32,15 +38,15 @@
     "author": "SAP SE",
     "license": "Apache-2.0",
     "dependencies": {
-        "@sap-ux/axios-extension": "^2.0.1",
-        "@sap-ux/btp-utils": "^2.0.1",
-        "@sap-ux/store": "^2.0.1",
-        "@sap-ux/system-access": "^1.0.1",
+        "@sap-ux/axios-extension": "^2.0.8",
+        "@sap-ux/btp-utils": "^2.0.6",
+        "@sap-ux/store": "^2.0.6",
+        "@sap-ux/system-access": "^1.0.10",
         "@sap/cf-tools": "^3.2.2",
         "@ui5/fs": "^4.0.1",
         "@ui5/logger": "^4.0.1",
-        "adm-zip": "^0.5.5",
-        "axios": "^1.8.3",
+        "adm-zip": "^0.6.0",
+        "axios": "^1.18.1",
         "crc": "^4.3.2",
         "dotenv": "^16.0.3",
         "filenamify": "^6.0.0",

package/types/ui5.d.ts

@@ -16,6 +16,8 @@ declare class Resource {
     setPath(path: string): void;
     getString(): Promise<string>;
     setString(string: string): void;
+    getBuffer(): Promise<Buffer>;
+    setBuffer(buffer: Buffer): void;
 }
 
 declare interface IWorkspace {

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

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

package/dist/util/renamingHandlers/renamingHandler.js

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