@ui5/task-adaptation 1.3.1 → 1.3.2

package/dist/annotations/serviceRequestor.js

@@ -0,0 +1,73 @@
+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 AnnotationsCacheManager from "../cache/annotationsCacheManager.js";
+import ServerError from "../model/serverError.js";
+import { getLogger } from "@ui5/logger";
+import { writeTempAnnotations } from "../util/commonUtil.js";
+const log = getLogger("@ui5/task-adaptation::ServiceRequestor");
+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 {
+                        throw new Error(`Failed to fetch annotation by '${args[0]}': ${error.message}`);
+                    }
+                }
+            }
+        };
+        return descriptor;
+    };
+}
+export default class ServiceRequestor {
+    abapRepoManager;
+    configuration;
+    constructor(configuration, abapRepoManager) {
+        this.abapRepoManager = abapRepoManager;
+        this.configuration = configuration;
+    }
+    //@ts-ignore tsx (esbuild) is not yet implemented the new decorators, but
+    //old decorators are already subject of compiler error, but it works. So we
+    //wait till esbuild implement it correctly.
+    async downloadAnnotation(uri, name, language) {
+        let cacheName = name;
+        if (language.sap) {
+            uri += `?sap-language=${language.sap}`;
+            cacheName += `-${language.sap}`;
+        }
+        const cacheManager = new AnnotationsCacheManager(this.configuration, cacheName);
+        log.verbose(`Getting annotation '${cacheName}' ${language} by '${uri}'`);
+        let files;
+        if (this.configuration.enableAnnotationCache) {
+            files = await cacheManager.getFiles(() => this.abapRepoManager.getAnnotationMetadata(uri), () => this.abapRepoManager.downloadAnnotationFile(uri));
+        }
+        else {
+            files = await this.abapRepoManager.downloadAnnotationFile(uri);
+        }
+        if (!files || files.size === 0) {
+            throw new Error(`No files were fetched for '${name}' by '${uri}'`);
+        }
+        const xml = [...files][0][1];
+        writeTempAnnotations(this.configuration, name, language, xml);
+        return xml;
+    }
+}
+__decorate([
+    retryOnError(1)
+], ServiceRequestor.prototype, "downloadAnnotation", null);
+//# sourceMappingURL=serviceRequestor.js.map

package/dist/annotations/transformers/convertV2ToV4.d.ts

@@ -0,0 +1,4 @@
+import Transformer, { TransformerInput } from "./transformer.js";
+export default class ConvertV2ToV4 implements Transformer {
+    transform({ json, xml }: TransformerInput): any;
+}

package/dist/annotations/transformers/convertV2ToV4.js

@@ -0,0 +1,13 @@
+import MetadataJsonUtil from "../converter/metadataJsonUtil.js";
+import UI5JsonConverter from "../converter/ui5JsonConverter.js";
+import UI5XmlConverter from "../converter/ui5XmlConverter.js";
+export default class ConvertV2ToV4 {
+    transform({ json, xml }) {
+        if (MetadataJsonUtil.getVersion(json) !== "4.0") {
+            const annotationsV4 = UI5JsonConverter.convertAnnotations(UI5XmlConverter.convertV2(xml));
+            MetadataJsonUtil.setAnnotations(json, annotationsV4);
+        }
+        return json;
+    }
+}
+//# sourceMappingURL=convertV2ToV4.js.map

package/dist/annotations/transformers/makeAnnotationNamespaceUnique.d.ts

@@ -0,0 +1,6 @@
+import Transformer, { TransformerInput } from "./transformer.js";
+export default class MakeAnnotationNamespaceUnique implements Transformer {
+    transform({ json, uri }: TransformerInput): any;
+    private createReference;
+    private getReferences;
+}

package/dist/annotations/transformers/makeAnnotationNamespaceUnique.js

@@ -0,0 +1,41 @@
+import MetadataJsonUtil from "../converter/metadataJsonUtil.js";
+import crc16 from "crc/crc16";
+export default class MakeAnnotationNamespaceUnique {
+    transform({ json, uri }) {
+        const uniquePart = crc16(uri).toString(16);
+        // First add current schema as reference
+        const schema = MetadataJsonUtil.getSchemaNode(json);
+        const references = this.getReferences(json);
+        references.push(this.createReference(schema, uri));
+        // Then rename the namespace/alias
+        schema._attributes.Namespace += "." + uniquePart;
+        delete schema._attributes["Alias"];
+        return json;
+    }
+    createReference(schema, uri) {
+        const attributes = {
+            Namespace: schema._attributes.Namespace
+        };
+        if (schema._attributes.Alias) {
+            attributes.Alias = schema._attributes.Alias;
+        }
+        ;
+        return {
+            _attributes: {
+                Uri: uri
+            },
+            "edmx:Include": {
+                _attributes: attributes
+            }
+        };
+    }
+    getReferences(json) {
+        const REFERENCE_NODE_NAME = "edmx:Reference";
+        const references = MetadataJsonUtil.getEdmx(json)[REFERENCE_NODE_NAME];
+        if (!Array.isArray(references)) {
+            MetadataJsonUtil.getEdmx(json)[REFERENCE_NODE_NAME] = [references];
+        }
+        return MetadataJsonUtil.getEdmx(json)[REFERENCE_NODE_NAME];
+    }
+}
+//# sourceMappingURL=makeAnnotationNamespaceUnique.js.map

package/dist/annotations/transformers/removeAllSchemaNodesExceptAnnotations.d.ts

@@ -0,0 +1,4 @@
+import Transformer, { TransformerInput } from "./transformer.js";
+export default class RemoveAllSchemaNodesExceptAnnotations implements Transformer {
+    transform({ json }: TransformerInput): any;
+}

package/dist/annotations/transformers/removeAllSchemaNodesExceptAnnotations.js

@@ -0,0 +1,14 @@
+import MetadataJsonUtil from "../converter/metadataJsonUtil.js";
+export default class RemoveAllSchemaNodesExceptAnnotations {
+    transform({ json }) {
+        const schema = MetadataJsonUtil.getSchemaNode(json);
+        for (const key of Object.keys(schema)) {
+            if (key !== "_attributes" && key !== "Annotations") {
+                delete schema[key];
+            }
+        }
+        return json;
+        // TODO: remove also references not used in annotations
+    }
+}
+//# sourceMappingURL=removeAllSchemaNodesExceptAnnotations.js.map

package/dist/annotations/transformers/transformer.d.ts

@@ -0,0 +1,12 @@
+import Language from "../../model/language.js";
+import ServiceRequestor from "../serviceRequestor.js";
+export interface TransformerInput {
+    uri: string;
+    json: any;
+    xml: string;
+    language: Language;
+    serviceRequestor: ServiceRequestor;
+}
+export default interface Transformer {
+    transform(input: TransformerInput): any;
+}

package/dist/annotations/transformers/transformer.js

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

package/dist/annotations/transformers/traverseReferences.d.ts

@@ -0,0 +1,9 @@
+import Transformer, { TransformerInput } from "../transformers/transformer.js";
+export default class TraverseReferences implements Transformer {
+    private metadataUrl?;
+    constructor(metadataUrl?: string);
+    transform({ json, language, serviceRequestor, uri: parentUrl }: TransformerInput): Promise<void>;
+    private shouldIgnoreUrl;
+    private mergeAnnotations;
+    private static isTraversable;
+}

package/dist/annotations/transformers/traverseReferences.js

@@ -0,0 +1,66 @@
+import MetadataJsonUtil from "../converter/metadataJsonUtil.js";
+import DataSourceODataAnnotation from "../dataSource/dataSourceODataAnnotation.js";
+import UrlUtil from "../../util/urlUtil.js";
+export default class TraverseReferences {
+    metadataUrl;
+    constructor(metadataUrl) {
+        this.metadataUrl = metadataUrl;
+    }
+    async transform({ json, language, serviceRequestor, uri: parentUrl }) {
+        const references = MetadataJsonUtil.getReferences(json).filter(TraverseReferences.isTraversable);
+        const promises = [];
+        for (const { includes, uri: relativeUrl } of references) {
+            const resourcePath = UrlUtil.getResourcePath(relativeUrl);
+            const absoluteUrl = UrlUtil.join(resourcePath, parentUrl);
+            if (this.shouldIgnoreUrl(absoluteUrl, [parentUrl, this.metadataUrl])) {
+                // If reference to metadata or its parent, don't traverse
+                continue;
+            }
+            const name = includes[0]?.namespace;
+            const dataSource = new DataSourceODataAnnotation(name, absoluteUrl, {}, this.metadataUrl);
+            promises.push(dataSource.downloadAnnotation(language, serviceRequestor)
+                .then(childAnnotation => ({ name, childAnnotation })));
+        }
+        const childAnnotations = await Promise.all(promises);
+        for (const { childAnnotation } of childAnnotations) {
+            this.mergeAnnotations(json, childAnnotation);
+        }
+        return json;
+    }
+    shouldIgnoreUrl(referenceUrl, urlsToIgnore) {
+        const toResourcePath = (url) => url && UrlUtil.getResourcePath(url);
+        const isEqual = (a, b) => a && b && a.toLowerCase() === b.toLowerCase();
+        return urlsToIgnore.map(toResourcePath).some(url => isEqual(referenceUrl, url));
+    }
+    mergeAnnotations(parentJson, nestedJson) {
+        const parentAnnotations = MetadataJsonUtil.getAnnotations(parentJson);
+        const parentMapByTarget = MetadataJsonUtil.mapAnnotationsPerTarget(parentJson);
+        const nestedMapByTarget = MetadataJsonUtil.mapAnnotationsPerTarget(nestedJson);
+        for (const nested of [...nestedMapByTarget].map(([target, { json }]) => ({ target, json }))) {
+            // If we found parent annotation with the same target - we extend it
+            // with missing <Annotation> nodes. If not, just add it to the end.
+            // Annotations do not have a merge logic If same target & term is in
+            // parent and nested, parent wins (same logic as UI5 in
+            // sap/ui/model/odata/v4/ODataMetaModel.js mergeAnnotations).
+            const parent = parentMapByTarget.get(nested.target);
+            if (parent) {
+                MetadataJsonUtil.toArrayTransform(parent.json, "Annotation");
+                const parentTerms = parent.json.Annotation.map((item) => item._attributes.Term);
+                for (const nestedAnnotation of MetadataJsonUtil.toArrayReadOnly(nested.json.Annotation)) {
+                    if (!parentTerms.includes(nestedAnnotation._attributes.Term)) {
+                        parent.json.Annotation.push(nestedAnnotation);
+                    }
+                }
+            }
+            else {
+                parentAnnotations.push(nested.json);
+            }
+        }
+        MetadataJsonUtil.setAnnotations(parentJson, parentAnnotations);
+    }
+    static isTraversable(reference) {
+        const IGNORED_NAMESPACES = ["com.sap.vocabularies.", "Org.OData."];
+        return !reference.includes.some(include => IGNORED_NAMESPACES.some(namespace => include.namespace.startsWith(namespace)));
+    }
+}
+//# sourceMappingURL=traverseReferences.js.map

package/dist/appVariantManager.d.ts

@@ -0,0 +1,12 @@
+import { IAppVariantInfo } from "./model/types.js";
+export default class AppVariantManager {
+    static process(appVariantResources: any[], projectNamespace: string, taskUtil: any): Promise<IAppVariantInfo>;
+    static getAppVariantResourcesToProcess(workspace: any): Promise<any[]>;
+    static updateChanges(appVariantResources: any[], projectNamespace: string): Promise<void>;
+    private static isManifestChange;
+    private static isManifestAppVariant;
+    static getAppVariantInfo(appVariantResources: any[]): Promise<IAppVariantInfo>;
+    private static validateManifest;
+    private static updateRelativePaths;
+    private static omitFiles;
+}

package/dist/appVariantManager.js

@@ -0,0 +1,102 @@
+import ResourceUtil from "./util/resourceUtil.js";
+import { posix as path } from "path";
+import { renameResources } from "./util/commonUtil.js";
+const EXTENSIONS_TO_PROCESS = "js,json,xml,html,properties,change,appdescr_variant,ctrl_variant,ctrl_variant_change,ctrl_variant_management_change,variant,fioriversion,codeChange,xmlViewChange,context";
+export default class AppVariantManager {
+    static async process(appVariantResources, projectNamespace, taskUtil) {
+        for (const resource of appVariantResources) {
+            this.omitFiles(resource, taskUtil);
+        }
+        await this.updateChanges(appVariantResources, projectNamespace);
+        return this.getAppVariantInfo(appVariantResources);
+    }
+    static getAppVariantResourcesToProcess(workspace) {
+        return workspace.byGlob(`/**/*.{${EXTENSIONS_TO_PROCESS}}`);
+    }
+    static async updateChanges(appVariantResources, projectNamespace) {
+        const changesFolder = ResourceUtil.getResourcePath(projectNamespace, "changes");
+        const changes = new Map();
+        const resourcesByPath = new Map();
+        let manifest;
+        for (const resource of appVariantResources) {
+            if (this.isManifestAppVariant(resource)) {
+                manifest = await ResourceUtil.getJson(resource);
+            }
+            const resourcePath = resource.getPath();
+            const basename = path.dirname(resourcePath);
+            if (basename.startsWith(changesFolder)) {
+                changes.set(resourcePath, await ResourceUtil.getString(resource));
+                resourcesByPath.set(resourcePath, resource);
+            }
+        }
+        this.updateRelativePaths(changes, projectNamespace);
+        this.validateManifest(manifest);
+        const renamedChanges = renameResources(changes, manifest.reference, manifest.id);
+        renamedChanges.forEach((renamedContent, resourcePath) => {
+            const resource = resourcesByPath.get(resourcePath);
+            ResourceUtil.setString(resource, renamedContent);
+        });
+    }
+    static isManifestChange(resource) {
+        const changesManifestFolder = path.join("changes", "manifest");
+        const resourcePath = typeof resource === "string" ? resource : resource.getPath();
+        const dirname = path.dirname(resourcePath);
+        return dirname.endsWith(changesManifestFolder);
+    }
+    static isManifestAppVariant(resource) {
+        const MANIFEST_APP_VARIANT = "manifest.appdescr_variant";
+        const basename = path.basename(resource.getPath());
+        return basename === MANIFEST_APP_VARIANT;
+    }
+    static async getAppVariantInfo(appVariantResources) {
+        let manifest;
+        const manifestChanges = [];
+        for (const resource of appVariantResources) {
+            if (this.isManifestAppVariant(resource)) {
+                manifest = await ResourceUtil.getJson(resource);
+            }
+            else if (this.isManifestChange(resource)) {
+                const content = await ResourceUtil.getString(resource);
+                manifestChanges.push(JSON.parse(content));
+            }
+        }
+        this.validateManifest(manifest);
+        // Order is important: apply manifest.json changes first, then *.change
+        // files. UI5 does the same.
+        const changes = (manifest.content ?? []).concat(manifestChanges);
+        return {
+            id: manifest.id,
+            reference: manifest.reference,
+            layer: manifest.layer,
+            changes
+        };
+    }
+    static validateManifest(manifest) {
+        if (!manifest) {
+            throw new Error("Adaptation project should contain manifest.appdescr_variant");
+        }
+    }
+    // TODO In future this should be handled by merger which needs to know change and target location
+    static updateRelativePaths(changes, projectNamespace) {
+        changes.forEach((jsonString, resourcePath) => {
+            if (this.isManifestChange(resourcePath)) {
+                const change = JSON.parse(jsonString);
+                if (change.changeType === "appdescr_app_addAnnotationsToOData") {
+                    for (const dataSource of Object.values(change.content.dataSource)) {
+                        if (!dataSource.uri.startsWith("/")) {
+                            const basepath = path.dirname(ResourceUtil.relativeToRoot(resourcePath, projectNamespace));
+                            dataSource.uri = path.join(basepath.replace(/^\//, ""), dataSource.uri);
+                        }
+                    }
+                    changes.set(resourcePath, JSON.stringify(change));
+                }
+            }
+        });
+    }
+    static omitFiles(resource, taskUtil) {
+        if (this.isManifestAppVariant(resource) || this.isManifestChange(resource)) {
+            taskUtil.setTag(resource, taskUtil.STANDARD_TAGS.OmitFromBuildResult, true);
+        }
+    }
+}
+//# sourceMappingURL=appVariantManager.js.map

package/dist/baseAppManager.d.ts

@@ -0,0 +1,29 @@
+import { IAppVariantInfo, IProjectOptions } from "./model/types.js";
+import IProcessor from "./processors/processor.js";
+export interface IBaseAppResources {
+    resources: any[];
+    manifestInfo: IManifestInfo;
+}
+export interface IManifestIdVersion {
+    id: string;
+    version: string;
+}
+export interface IManifestInfo extends IManifestIdVersion {
+    i18nPath: string;
+}
+export default class BaseAppManager {
+    static process(baseAppFiles: Map<string, string>, appVariantInfo: IAppVariantInfo, options: IProjectOptions, processor: IProcessor): Promise<IBaseAppResources>;
+    private static updateAdaptationProperties;
+    static getIdVersion(manifest: any): IManifestIdVersion;
+    static getManifestInfo(manifest: any): IManifestInfo;
+    private static extractI18nPathFromManifest;
+    private static extractI18NFromBundleName;
+    private static extractI18NFromBundleUrl;
+    private static getBaseAppManifest;
+    private static fillAppVariantIdHierarchy;
+    private static VALIDATION_RULES;
+    static validateProperty(value: string, property: string): void;
+    static applyDescriptorChanges(baseAppManifest: any, { layer, changes, id }: IAppVariantInfo): Promise<void>;
+    private static adjustAddNewModelEnhanceWith;
+    static writeToWorkspace(baseAppFiles: Map<string, string>, projectNamespace: string): any[];
+}

package/dist/baseAppManager.js

@@ -0,0 +1,139 @@
+import { Applier, Change, RegistrationBuild } from "../dist/bundle.js";
+import { dotToUnderscore, removePropertiesExtension } from "./util/commonUtil.js";
+import BuildStrategy from "./buildStrategy.js";
+import ResourceUtil from "./util/resourceUtil.js";
+import { getLogger } from "@ui5/logger";
+import { renameResources } from "./util/commonUtil.js";
+const log = getLogger("@ui5/task-adaptation::BaseAppManager");
+export default class BaseAppManager {
+    static async process(baseAppFiles, appVariantInfo, options, processor) {
+        const baseAppManifest = this.getBaseAppManifest(baseAppFiles);
+        const { id, version } = this.getIdVersion(baseAppManifest.content);
+        this.validateProperty(id, "sap.app/id");
+        this.validateProperty(version, "sap.app/applicationVersion/version");
+        const renamedBaseAppFiles = renameResources(baseAppFiles, appVariantInfo.reference, appVariantInfo.id);
+        const { filepath, content } = this.getBaseAppManifest(renamedBaseAppFiles);
+        await processor.updateLandscapeSpecificContent(content, renamedBaseAppFiles);
+        this.fillAppVariantIdHierarchy(processor, id, version, content);
+        this.updateAdaptationProperties(content);
+        await this.applyDescriptorChanges(content, appVariantInfo);
+        renamedBaseAppFiles.set(filepath, JSON.stringify(content));
+        return {
+            resources: this.writeToWorkspace(renamedBaseAppFiles, options.projectNamespace),
+            manifestInfo: this.getManifestInfo(content)
+        };
+    }
+    static updateAdaptationProperties(content) {
+        if (content["sap.fiori"]?.cloudDevAdaptationStatus) {
+            delete content["sap.fiori"].cloudDevAdaptationStatus;
+        }
+        if (content["sap.ui5"] == null) {
+            content["sap.ui5"] = {};
+        }
+        content["sap.ui5"].isCloudDevAdaptation = true;
+    }
+    static getIdVersion(manifest) {
+        const id = manifest["sap.app"]?.id;
+        const version = manifest["sap.app"]?.applicationVersion?.version;
+        return { id, version };
+    }
+    static getManifestInfo(manifest) {
+        const { id, version } = this.getIdVersion(manifest);
+        const i18nNode = manifest["sap.app"]?.i18n;
+        const i18nPath = this.extractI18nPathFromManifest(id, i18nNode);
+        return { id, version, i18nPath };
+    }
+    static extractI18nPathFromManifest(sapAppId, i18nNode) {
+        if (typeof i18nNode === "object") {
+            return i18nNode["bundleUrl"] ? this.extractI18NFromBundleUrl(i18nNode) : this.extractI18NFromBundleName(i18nNode, sapAppId);
+        }
+        else {
+            return `${sapAppId?.replaceAll(".", "/")}/${i18nNode}`;
+        }
+    }
+    static extractI18NFromBundleName(i18nNode, sapAppId) {
+        return i18nNode["bundleName"].replace(sapAppId, "").replaceAll(".", "/").substring(1);
+    }
+    static extractI18NFromBundleUrl(i18nNode) {
+        return removePropertiesExtension(i18nNode["bundleUrl"]);
+    }
+    static getBaseAppManifest(baseAppFiles) {
+        const manifestContent = baseAppFiles.get("manifest.json");
+        if (manifestContent) {
+            return {
+                content: JSON.parse(manifestContent),
+                filepath: "manifest.json"
+            };
+        }
+        throw new Error("Original application should have manifest.json in root folder");
+    }
+    static fillAppVariantIdHierarchy(processor, id, version, baseAppManifest) {
+        log.verbose("Filling up app variant hierarchy in manifest.json");
+        if (baseAppManifest["sap.ui5"] == null) {
+            baseAppManifest["sap.ui5"] = {};
+        }
+        if (baseAppManifest["sap.ui5"].appVariantIdHierarchy == null) {
+            baseAppManifest["sap.ui5"].appVariantIdHierarchy = [];
+        }
+        const appVariantIdHierarchyItem = processor.createAppVariantHierarchyItem(id, version);
+        baseAppManifest["sap.ui5"].appVariantIdHierarchy.unshift(appVariantIdHierarchyItem);
+    }
+    static VALIDATION_RULES = new Map([["sap.app/id", (value) => {
+                if (!value.includes(".")) {
+                    throw new Error(`The original application id '${value}' should consist of multiple segments split by dot, e.g.: original.id`);
+                }
+            }]]);
+    static validateProperty(value, property) {
+        if (!value) {
+            throw new Error(`Original application manifest should have ${property}`);
+        }
+        let validatationRule = this.VALIDATION_RULES.get(property);
+        if (validatationRule) {
+            validatationRule(value);
+        }
+    }
+    static async applyDescriptorChanges(baseAppManifest, { layer, changes, id }) {
+        log.verbose("Applying appVariant changes");
+        const changesContent = new Array();
+        const i18nBundleName = dotToUnderscore(id);
+        for (const change of structuredClone(changes)) {
+            if (layer) {
+                change.layer = layer;
+            }
+            changesContent.push(new Change(change));
+            this.adjustAddNewModelEnhanceWith(change, i18nBundleName);
+        }
+        if (changesContent.length > 0) {
+            const strategy = new BuildStrategy(RegistrationBuild);
+            await Applier.applyChanges(baseAppManifest, changesContent, strategy);
+        }
+    }
+    static adjustAddNewModelEnhanceWith(change, i18nBundleName) {
+        if (change.changeType === "appdescr_ui5_addNewModelEnhanceWith") {
+            if (change.texts == null) {
+                // We need to add texts properties to changes because not all
+                // have texts property. Changes without texts property can
+                // causes issues in bundle.js This is needed for now, and will
+                // be removed as soon as change merger in openUI5 is updated
+                change.texts = { i18n: change.content?.bundleUrl || "i18n/i18n.properties" };
+            }
+            change.texts.i18n = i18nBundleName + "/" + change.texts.i18n;
+        }
+    }
+    static writeToWorkspace(baseAppFiles, projectNamespace) {
+        const IGNORE_FILES = [
+            "manifest-bundle.zip",
+            "Component-preload.js",
+            "sap-ui-cachebuster-info.json"
+        ];
+        const resources = [];
+        for (let filename of baseAppFiles.keys()) {
+            if (!IGNORE_FILES.includes(filename)) {
+                const resource = ResourceUtil.createResource(filename, projectNamespace, baseAppFiles.get(filename));
+                resources.push(resource);
+            }
+        }
+        return resources;
+    }
+}
+//# sourceMappingURL=baseAppManager.js.map

package/dist/buildStrategy.d.ts

@@ -0,0 +1,7 @@
+export default class BuildStrategy {
+    private registrationBuild;
+    constructor(registrationBuild: any);
+    registry(): Promise<any>;
+    handleError(error: any): void;
+    processTexts(manifest: any): any;
+}

package/dist/buildStrategy.js

@@ -0,0 +1,19 @@
+export default class BuildStrategy {
+    registrationBuild;
+    constructor(registrationBuild) {
+        this.registrationBuild = registrationBuild;
+    }
+    registry() {
+        return Promise.resolve(this.registrationBuild);
+    }
+    handleError(error) {
+        throw error;
+    }
+    processTexts(manifest) {
+        if (typeof manifest["sap.app"].i18n === "string") {
+            manifest["sap.app"].i18n = { bundleUrl: manifest["sap.app"].i18n };
+        }
+        return manifest;
+    }
+}
+//# sourceMappingURL=buildStrategy.js.map

package/dist/bundle.d.ts

@@ -0,0 +1,25 @@
+export declare const RegistrationBuild: () => void;
+
+export declare class Applier {
+    static applyChanges(manifest: any, changes: Change[], strategy: any): Promise<void>;
+}
+
+export declare class Change {
+    constructor(change: any);
+    getLayer(): string;
+    _oDefinition: any;
+}
+
+export declare class V2MetadataConverter {
+    convertXMLMetadata(jsdom: any): any;
+}
+
+export declare class V4MetadataConverter {
+    convertXMLMetadata(jsdom: any): any;
+}
+
+export declare class URI {
+    constructor(relativeUrl: string);
+    absoluteTo(url: string): string;
+    static parse(url: string): { path: string };
+}