@ui5/task-adaptation 1.6.5 → 1.6.7

package/dist/repositories/cacheRepository.js

@@ -0,0 +1,29 @@
+import CacheHolder from "../cache/cacheHolder.js";
+export default class CacheRepository {
+    configuration;
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async getAppVariantIdHierarchy(_appId) {
+        const { appName } = this.configuration;
+        if (!appName) {
+            throw new Error("previewManifest requires 'appName' in the ui5.yaml configuration");
+        }
+        return [{
+                appName,
+                cacheBusterToken: Promise.resolve("")
+            }];
+    }
+    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;
+    }
+    downloadAnnotationFile(uri) {
+        throw new Error(`Download annotation file for uri: ${uri} is not available for CacheRepository.`);
+    }
+}
+//# sourceMappingURL=cacheRepository.js.map

package/dist/repositories/html5Repository.d.ts

@@ -10,7 +10,7 @@ export default class HTML5Repository implements IRepository {
     private validator;
     constructor(configuration: IConfiguration);
     getAppVariantIdHierarchy(_appId: string): Promise<IHtml5Resource[]>;
-    fetch(resource: IHtml5Resource): Promise<Map<string, string>>;
+    fetch(resource: IHtml5Resource): Promise<Map<string, Buffer>>;
     getMetadata(): Promise<any>;
     private getHtml5RepoInfo;
     private getHTML5Credentials;

package/dist/repositories/localRepository.d.ts

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

package/dist/repositories/repository.d.ts

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

package/dist/util/commonUtil.d.ts

@@ -2,6 +2,11 @@ import { IConfiguration } from "../model/types.js";
 import Language from "../model/language.js";
 import AppVariant from "../appVariant.js";
 export declare function dotToUnderscore(value: string): string;
+export declare function bufferToString(buffer: Buffer): string;
+export declare function bufferToJson(buffer: Buffer): any;
+export declare function bufferToNormalizedString(buffer: Buffer): string;
+export declare function stringToBuffer(value: string): Buffer;
+export declare function jsonToBuffer(json: any): Buffer;
 export declare function validateConfiguration<T extends object>(options: T, properties: Array<keyof T>): void;
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
 export declare function escapeRegex(update: string): string;
@@ -12,7 +17,7 @@ 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;
+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.

package/dist/util/commonUtil.js

@@ -9,6 +9,21 @@ const MANIFEST_CHANGE = "appdescr_";
 export function dotToUnderscore(value) {
     return value.replace(/\./g, "_");
 }
+export function bufferToString(buffer) {
+    return buffer.toString("utf8");
+}
+export function bufferToJson(buffer) {
+    return JSON.parse(bufferToString(buffer));
+}
+export function bufferToNormalizedString(buffer) {
+    return bufferToString(buffer).replaceAll("\r\n", "\n");
+}
+export function stringToBuffer(value) {
+    return Buffer.from(value, "utf8");
+}
+export function jsonToBuffer(json) {
+    return stringToBuffer(JSON.stringify(json));
+}
 export function validateConfiguration(options, properties) {
     validateObject(options, properties, "should be specified in ui5.yaml configuration");
 }
@@ -93,7 +108,7 @@ export function getUniqueName(existingNames, template) {
 }
 export function isManifestChange(filename, content) {
     if (filename.endsWith(CHANGES_EXT)) {
-        const change = JSON.parse(content);
+        const change = bufferToJson(content);
         return change.changeType?.startsWith(MANIFEST_CHANGE);
     }
     return false;

package/dist/util/fsUtil.d.ts

@@ -1,10 +1,10 @@
 export default class FsUtil {
-    static readInProject(filepath: string, encoding?: BufferEncoding): Promise<Buffer | string>;
+    static readInProject(filepath: string): Promise<Buffer>;
     /**
      * Check whether a file or directory exists (non-throwing).
      * @param filePath Absolute or relative path
      * @returns true if the path exists, false if not
      */
     private static fileExists;
-    static readFilesRecursively(rootDirectory: string): Promise<Map<string, string>>;
+    static readFilesRecursively(rootDirectory: string): Promise<Map<string, Buffer>>;
 }

package/dist/util/fsUtil.js

@@ -5,11 +5,11 @@ export default class FsUtil {
      * Read the file by filepath from the project root (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located).
      * @param filepath The relative file path from the project root (e.g. 'ui5AppInfo.json').
-     * @returns A promise that resolves to the file content as a string.
+     * @returns A promise that resolves to the file content as a Buffer.
      */
-    static async readInProject(filepath, encoding) {
+    static async readInProject(filepath) {
         try {
-            return await fs.readFile(path.join(process.cwd(), filepath), encoding);
+            return await fs.readFile(path.join(process.cwd(), filepath));
         }
         catch (error) {
             const isProjectRoot = await FsUtil.fileExists(path.join(process.cwd(), "ui5.yaml"));
@@ -44,7 +44,7 @@ export default class FsUtil {
             const parentPath = entry.parentPath ?? entry.path; // node v20.11.0 fallback
             const entryPath = path.join(parentPath, entry.name);
             const relativeFilePath = path.relative(rootDirectory, entryPath).replaceAll("\\", "/");
-            const content = await fs.readFile(entryPath, "utf-8");
+            const content = await fs.readFile(entryPath);
             return [relativeFilePath, content];
         });
         return new Map(await Promise.all(fileReadTasks));

package/dist/util/manifestUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the SAPUI5 dependency ids (libs and components) declared under
+ * "sap.ui5"/dependencies of a parsed manifest. These point at other apps and
+ * must not be renamed, so callers add them to the renamer ignore list.
+ */
+export declare function getSAPUI5DependencyIds(manifest: any): string[];

package/dist/util/manifestUtil.js

@@ -0,0 +1,15 @@
+/**
+ * Returns the SAPUI5 dependency ids (libs and components) declared under
+ * "sap.ui5"/dependencies of a parsed manifest. These point at other apps and
+ * must not be renamed, so callers add them to the renamer ignore list.
+ */
+export function getSAPUI5DependencyIds(manifest) {
+    const dependencies = manifest?.["sap.ui5"]?.dependencies;
+    if (!dependencies) {
+        return [];
+    }
+    const libs = dependencies.libs ? Object.keys(dependencies.libs) : [];
+    const components = dependencies.components ? Object.keys(dependencies.components) : [];
+    return [...libs, ...components];
+}
+//# sourceMappingURL=manifestUtil.js.map

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

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

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>>;
 }