@ui5/task-adaptation 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -2,7 +2,13 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.1.0...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.1.2...HEAD).
+
+<a name="v1.1.2"></a>
+## [v1.1.2] - 2024-02-23
+
+<a name="v1.1.1"></a>
+## [v1.1.1] - 2024-02-16
 
 <a name="v1.1.0"></a>
 ## [v1.1.0] - 2024-01-30
@@ -73,6 +79,8 @@ A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task
 <a name="v1.0.0"></a>
 ## v1.0.0 - 2020-12-09
 
+[v1.1.2]: https://github.com/SAP/ui5-task-adaptation/compare/v1.1.1...v1.1.2
+[v1.1.1]: https://github.com/SAP/ui5-task-adaptation/compare/v1.1.0...v1.1.1
 [v1.1.0]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.23...v1.1.0
 [v1.0.23]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.21...v1.0.23
 [v1.0.21]: https://github.com/SAP/ui5-task-adaptation/compare/v1.0.20...v1.0.21

package/README.md

@@ -4,7 +4,7 @@
 [![npm version](https://badge.fury.io/js/@ui5%2Ftask-adaptation.svg)](https://badge.fury.io/js/@ui5%2Ftask-adaptation)
 
 ## Description
-A custom task for [ui5-builder](https://github.com/SAP/ui5-builder) that allows building [UI5 Flexibility adaptation projects](https://help.sap.com/viewer/584e0bcbfd4a4aff91c815cefa0bce2d/Cloud/en-US/019b0c38a6b043d1a66b11d992eed290.html) for SAP BTP, Cloud Foundry environment.
+A custom task for [ui5-builder](https://github.com/SAP/ui5-builder) that allows building SAPUI5 adaptation projects for [SAP S/4HANA Cloud](https://help.sap.com/docs/bas/584e0bcbfd4a4aff91c815cefa0bce2d/6fc4e11a4b1941efa8e37a428d046f8f.html?locale=en-US&state=PRODUCTION&version=Cloud) and [SAP BTP, Cloud Foundry environment](https://help.sap.com/viewer/584e0bcbfd4a4aff91c815cefa0bce2d/Cloud/en-US/019b0c38a6b043d1a66b11d992eed290.html).
 
 ## How to obtain support
 In case you need any support, please create a [GitHub issue](https://github.com/SAP/ui5-task-adaptation/issues).

package/dist/annotationManager.d.ts

@@ -12,10 +12,7 @@ export default class AnnotationManager {
     ANNOTATIONS_FOLDER: string;
     process(renamedBaseAppManifest: any, languages: Language[]): Promise<Map<string, string>>;
     private normalizeAppVariantId;
-    private createAnnotationFile;
     private updateManifestModel;
-    private updateManifestDataSources;
     private createManifestModel;
     private enhanceManifestModel;
-    private createODataModels;
 }

package/dist/annotationManager.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const baseAppManager_1 = require("./baseAppManager");
+const dataSourceManager_1 = require("./annotations/dataSource/dataSourceManager");
 const i18nManager_1 = require("./i18nManager");
-const oDataV2Model_1 = require("./annotations/oDataV2Model");
 const serviceRequestor_1 = require("./annotations/serviceRequestor");
-const xmlUtil_1 = require("./util/xmlUtil");
 const path_1 = require("path");
 const I18N_DEFAULT_PATH = "i18n/annotations";
 const I18N_DEFAULT_MODEL_NAME = "@i18n";
 const SAPUI5 = "sap.ui5";
-const SAPAPP = "sap.app";
 class AnnotationManager {
     constructor(configuration, abapRepoManager) {
         this.ANNOTATIONS_FOLDER = "annotations";
@@ -23,46 +21,26 @@ class AnnotationManager {
         //TODO: switch to this after resolving @i18n custom model
         const modelName = I18N_DEFAULT_MODEL_NAME; //`i18n_a9n_${normalisedId}`;
         const i18nPathName = path_1.posix.join(I18N_DEFAULT_PATH, normalisedId);
-        const annotationFiles = new Map();
-        const metaInfo = new Array();
         const i18nManager = new i18nManager_1.default(modelName, id, languages);
-        const oDataModels = this.createODataModels(renamedBaseAppManifest);
-        for (const oDataModel of oDataModels) {
-            for (const { annotationJsons, annotationName } of oDataModel.getAnnotationJsons(languages)) {
-                const annotationXml = await this.createAnnotationFile(await annotationJsons, i18nManager);
-                const annotationFileName = `annotations/annotation_${annotationName}.xml`;
-                annotationFiles.set(annotationFileName, annotationXml);
-                metaInfo.push({ annotationFileName, annotationName });
-            }
-        }
-        if (metaInfo.length > 0) {
-            this.updateManifestDataSources(renamedBaseAppManifest, metaInfo);
-            if (i18nManager.hasTranslations()) {
-                this.updateManifestModel(renamedBaseAppManifest, modelName, i18nPathName);
-            }
-        }
+        const serviceRequestor = new serviceRequestor_1.default(this.configuration, this.abapRepoManager);
+        const dataSourceManager = new dataSourceManager_1.default();
+        dataSourceManager.addDataSources(renamedBaseAppManifest["sap.app"]?.dataSources, this.configuration);
+        const annotationFiles = await dataSourceManager.createAnnotationFiles(languages, i18nManager, serviceRequestor);
         const i18nFiles = i18nManager.createFiles(i18nPathName);
+        if (i18nManager.hasTranslations()) {
+            this.updateManifestModel(renamedBaseAppManifest, modelName, i18nPathName);
+        }
         return new Map([...annotationFiles, ...i18nFiles]);
     }
     normalizeAppVariantId(id, replaceWith = "") {
         return id.replace(/[.\W]+/gi, replaceWith);
     }
-    async createAnnotationFile(annotationJsons, i18nManager) {
-        const annotationJson = i18nManager.populateTranslations(annotationJsons);
-        return xmlUtil_1.default.jsonToXml(annotationJson.json);
-    }
     updateManifestModel(renamedBaseAppManifest, modelName, i18nPathName) {
         const uri = `${i18nPathName}/i18n.properties`;
         this.enhanceManifestModel(renamedBaseAppManifest, modelName, uri);
         //TODO: switch to this after resolving @i18n custom model
         //this.createManifestModel(renamedBaseAppManifest, modelName, uri);
     }
-    updateManifestDataSources(renamedBaseAppManifest, metaInfo) {
-        const dataSources = renamedBaseAppManifest[SAPAPP]?.dataSources;
-        for (const { annotationName, annotationFileName } of metaInfo) {
-            dataSources[annotationName].uri = annotationFileName;
-        }
-    }
     createManifestModel(manifest, modelName, uri) {
         let sapui5 = manifest[SAPUI5] == null ? manifest[SAPUI5] = {} : manifest[SAPUI5];
         if (sapui5.models == null) {
@@ -97,19 +75,6 @@ class AnnotationManager {
             this.createManifestModel(manifest, modelToEnhance, bundleUrl);
         }
     }
-    createODataModels(renamedBaseAppManifest) {
-        const serviceRequestor = new serviceRequestor_1.default(this.configuration, this.abapRepoManager);
-        const oDataModels = [
-            new oDataV2Model_1.default(serviceRequestor)
-        ];
-        const dataSources = renamedBaseAppManifest["sap.app"]?.dataSources;
-        if (dataSources) {
-            for (const name of Object.keys(dataSources)) {
-                oDataModels.forEach(model => model.addDataSource(dataSources[name], name));
-            }
-        }
-        return oDataModels;
-    }
 }
 exports.default = AnnotationManager;
 //# sourceMappingURL=annotationManager.js.map

package/dist/annotations/comparator/comparator.d.ts

@@ -0,0 +1,47 @@
+export interface IDiffProperty {
+    object: any;
+    property: string | number;
+}
+export declare class Diff {
+    __old: string;
+    __new: string;
+    constructor(__old: string, __new: string);
+    toString(): string;
+}
+export interface DiffJson {
+    json: any;
+    properties: Set<IDiffProperty>;
+}
+export default class Comparator {
+    private diffs;
+    private xml_a;
+    private xml_b;
+    constructor(xml_a: string, xml_b: string);
+    compare(): DiffJson;
+    private traverseCompare;
+    /**
+     * If one language annotation has one property it is an object, if other
+     * language same annotation consists of multiple properties, we need to
+     * equal them, so they are both arrays (see test 01-04).
+     */
+    private arrayIfNeeded;
+    /**
+     * If some node (Annotations, Annotation, PropertyValue, LabeledElement) has
+     * an id, we can compare by id, so the items order doesn't matter anymore.
+     * @param a array of nodes with id of one language
+     * @param b array of nodes with id of the other language
+     * @param idProperty property which value is an id (e.g. Target="<unique-id>")
+     * @param property node name (Annotations, Annotation, PropertyValue, ...)
+     */
+    private traverseById;
+    /**
+     *  Some nodes, like Annotations, Annotation, PropertyValue have unique id
+     *  among other same nodes. We can use it to know what to compare with what
+     *  even if the order is different. IdProperty is a property name of that id,
+     *  e.g. for Annotations it will be Target (like in
+     *  Target="<some-unique-id>").
+     *  @param property node which might have an id: Annotations, PropertyValue
+     *  @return the property name which represents id: Target, Property
+     */
+    private getIdProperty;
+}

package/dist/annotations/comparator/comparator.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Diff = void 0;
+const commonUtil_1 = require("../../util/commonUtil");
+const annotationDiffStructureError_1 = require("../../model/annotationDiffStructureError");
+const interchangableCase_1 = require("./interchangableCase");
+const metadataJsonUtil_1 = require("../converter/metadataJsonUtil");
+const xmlUtil_1 = require("../../util/xmlUtil");
+class Diff {
+    constructor(__old, __new) {
+        this.__old = __old;
+        this.__new = __new;
+    }
+    toString() {
+        return `{ __old: ${this.__old},  __new: ${this.__new} }`;
+    }
+}
+exports.Diff = Diff;
+class Comparator {
+    constructor(xml_a, xml_b) {
+        this.diffs = new Set();
+        this.xml_a = xml_a;
+        this.xml_b = xml_b;
+    }
+    compare() {
+        const json_a = typeof this.xml_a === "string" ? xmlUtil_1.default.xmlToJson(this.xml_a) : this.xml_a;
+        const json_b = typeof this.xml_b === "string" ? xmlUtil_1.default.xmlToJson(this.xml_b) : this.xml_b;
+        const scheme_a = metadataJsonUtil_1.default.getSchemaNode(json_a);
+        const scheme_b = metadataJsonUtil_1.default.getSchemaNode(json_b);
+        if (scheme_a && scheme_b) {
+            // we compare only Annotations, other types are left as it is
+            this.traverseCompare(scheme_a, scheme_b, "Annotations");
+        }
+        return {
+            json: json_a,
+            properties: this.diffs
+        };
+    }
+    traverseCompare(obj_a, obj_b, property) {
+        let a = obj_a[property];
+        let b = obj_b[property];
+        if (typeof a === "object" && !(a instanceof Diff) && typeof b !== "object" ||
+            typeof b === "object" && !(b instanceof Diff) && typeof a !== "object" ||
+            a == null || b == null) {
+            // When during traversing we end up in primitives like string, we
+            // compare the values. If one of them is not primitive or oone of
+            // them is undefined, we throw exception (see test 06, 07).
+            throw new annotationDiffStructureError_1.default({ a, b });
+        }
+        else if (typeof a !== "object" && typeof b !== "object") {
+            // If primitive values are not same - we assume they are
+            // translations, so we save them.
+            if (a !== b) {
+                obj_a[property] = new Diff(a, b);
+                this.diffs.add({ object: obj_a, property });
+            }
+        }
+        else {
+            a = this.arrayIfNeeded(obj_a, obj_b, property);
+            b = this.arrayIfNeeded(obj_b, obj_a, property);
+            if (Array.isArray(a)) {
+                let idProperty = this.getIdProperty(property);
+                if (idProperty) {
+                    this.traverseById(a, b, idProperty, property);
+                }
+                else {
+                    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+                        if (a[i] && b[i]) {
+                            this.traverseCompare(a, b, i);
+                        }
+                        else {
+                            // If the number of items of nodes without id are
+                            // different, we throw error (see test 08).
+                            throw new annotationDiffStructureError_1.default({ a, b });
+                        }
+                    }
+                }
+            }
+            else {
+                for (const key of Object.keys(a)) {
+                    this.traverseCompare(a, b, key);
+                }
+            }
+        }
+    }
+    /**
+     * If one language annotation has one property it is an object, if other
+     * language same annotation consists of multiple properties, we need to
+     * equal them, so they are both arrays (see test 01-04).
+     */
+    arrayIfNeeded(obj_a, obj_b, property) {
+        if (!Array.isArray(obj_a[property])) {
+            // If node with id - make array anyway, so it's easier to compare (see test 04).
+            if (simpleIdentifiers.has(property) || Array.isArray(obj_b[property])) {
+                obj_a[property] = [obj_a[property]];
+            }
+        }
+        return obj_a[property];
+    }
+    /**
+     * If some node (Annotations, Annotation, PropertyValue, LabeledElement) has
+     * an id, we can compare by id, so the items order doesn't matter anymore.
+     * @param a array of nodes with id of one language
+     * @param b array of nodes with id of the other language
+     * @param idProperty property which value is an id (e.g. Target="<unique-id>")
+     * @param property node name (Annotations, Annotation, PropertyValue, ...)
+     */
+    traverseById(a, b, idProperty, property) {
+        if (typeof property !== "string") {
+            return;
+        }
+        let items_a = new Items(a, idProperty);
+        let items_b = new Items(b, idProperty);
+        const includer_a = new Includer(a, property);
+        const includer_b = new Includer(b, property);
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            const id_a = a[i]?._attributes[idProperty];
+            const id_b = b[i]?._attributes[idProperty];
+            if (id_a !== id_b) {
+                // We go down the array and if suddenly the ids for comparing
+                // items are not the same, we need to find the item with the
+                // same id if it exists.
+                if (items_b.has(id_a) && items_a.has(id_b)) {
+                    // If we found the item with the same id, we swap places
+                    // with current item (see test 05).
+                    items_b.swap(id_a, i);
+                }
+                else if (!items_a.has(id_b) && id_b) {
+                    // If 1st language missing the item, include it from 2nd (see test 02).
+                    includer_a.include(b, i);
+                }
+                else if (!items_b.has(id_a) && id_a) {
+                    // If 2nd language missing the item, include it from 1st (see test 03).
+                    includer_b.include(a, i);
+                }
+            }
+            this.traverseCompare(a, b, i);
+        }
+    }
+    /**
+     *  Some nodes, like Annotations, Annotation, PropertyValue have unique id
+     *  among other same nodes. We can use it to know what to compare with what
+     *  even if the order is different. IdProperty is a property name of that id,
+     *  e.g. for Annotations it will be Target (like in
+     *  Target="<some-unique-id>").
+     *  @param property node which might have an id: Annotations, PropertyValue
+     *  @return the property name which represents id: Target, Property
+     */
+    getIdProperty(property) {
+        return simpleIdentifiers.get(property);
+    }
+}
+exports.default = Comparator;
+class Includer {
+    /**
+     * It will decide what to do with the item missing in one language.
+     * @param target an array which might miss the item
+     * @param property the node name needed to decide how to include the missing
+     * item in array
+     * @param shouldClear if the item is missing and it's not Label or QuickInfo
+     * or Heading, we clear all the properties except Ids, so in i18n.properties
+     * they will have empty values. Because we don't know what should be there.
+     */
+    constructor(target, property, shouldClear = true) {
+        this.ALL_DIFF_CASES = [
+            new interchangableCase_1.default()
+        ];
+        this.diffCases = new Array();
+        this.shouldClear = shouldClear;
+        this.target = target;
+        this.property = property;
+        for (const diffCase of this.ALL_DIFF_CASES) {
+            if (diffCase.canAccept(target, property)) {
+                this.diffCases.push(diffCase);
+            }
+        }
+    }
+    /**
+     * If in some language some array missing the item, we include the missing
+     * item from other language array with the same id.
+     * @param source the item from other language array that is missed in target
+     * @param index here to put it in the array
+     */
+    include(source, index) {
+        // Insert node with empty value (see test 02) if missing in default
+        // language or default language value if missing in other language
+        // (see test 03).
+        const clone = Includer.cloneAndClear(source[index], this.shouldClear);
+        (0, commonUtil_1.insertInArray)(this.target, index, clone);
+        // Some annotations like Label, QuickInfo or Heading are
+        // interchangable so if QuickInfo is missing we can copy the value
+        // from Label or Heading (see test 01).
+        for (const diffCase of this.diffCases) {
+            diffCase.accept(this.target, index, this.property);
+        }
+    }
+    /**
+     * if the item is missing in default language, and it's not Label or
+     * QuickInfo or Heading, we clear all the properties except Ids, so in
+     * i18n.properties they will have empty values. Because we don't know what
+     * should be there. But if the item is missing in language other than
+     * default, we include the copy of item from default language and not
+     * clearing them (see test 02, 04).
+     */
+    static cloneAndClear(obj, shouldClear = true) {
+        const clone = structuredClone(obj);
+        if (shouldClear) {
+            (0, commonUtil_1.traverse)(clone, [], (json, key) => {
+                if (typeof key !== "string" || !simpleIdentifiersReversed.has(key)) {
+                    json[key] = "";
+                }
+            });
+        }
+        return clone;
+    }
+}
+class Items {
+    /**
+     * Map of id per item which is lazy initialized if needed
+     * @param array
+     * @param idProperty
+     */
+    constructor(array, idProperty) {
+        this.objectMap = null;
+        this.array = array;
+        this.idProperty = idProperty;
+    }
+    /**
+     * Find the item with by id and swap their places.
+     * @param id of the item which seems like not in the place it should be
+     * @param newIndex new place where the item should actually be
+     */
+    swap(id, newIndex) {
+        const oldIndex = this.initMap().get(id);
+        const temp = this.array[newIndex];
+        this.array[newIndex] = this.array[oldIndex];
+        this.array[oldIndex] = temp;
+        this.initMap(true);
+    }
+    has(idProperty) {
+        return this.initMap().has(idProperty);
+    }
+    get(idProperty) {
+        return this.array[this.initMap().get(idProperty)];
+    }
+    /**
+     * Lazy init the map only if the order of items are messed up, which
+     * actually an eexception, so will make it lazy way.
+     * @param force force to update.
+     * @returns the map id per item index.
+     */
+    initMap(force = false) {
+        if (this.objectMap == null || force) {
+            this.objectMap = new Map(this.array.map((item, index) => [item._attributes[this.idProperty], index]));
+        }
+        return this.objectMap;
+    }
+}
+class Identifiers extends Map {
+    has(property) {
+        return typeof property === "string" && super.has(property);
+    }
+    get(property) {
+        return typeof property === "string" ? super.get(property) : undefined;
+    }
+}
+// According to OData schema some nodes MUST have the ids, by these nodes the
+// property which contains the id is named differently as you can see.
+const simpleIdentifiers = new Identifiers([
+    ["Annotations", "Target"],
+    ["Annotation", "Term"],
+    ["LabeledElement", "Name"],
+    ["PropertyValue", "Property"]
+]);
+const simpleIdentifiersReversed = new Identifiers([...simpleIdentifiers].map(([name, idProperty]) => [idProperty, name]));
+//# sourceMappingURL=comparator.js.map

package/dist/annotations/comparator/diffCase.d.ts

@@ -0,0 +1,4 @@
+export default interface DiffCase {
+    accept(target: any[], i: number, name?: string): void;
+    canAccept(target: any[], name?: string): boolean;
+}

package/dist/annotations/comparator/diffCase.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=diffCase.js.map

package/dist/annotations/comparator/interchangableCase.d.ts

@@ -0,0 +1,25 @@
+import DiffCase from "./diffCase";
+export default class InterchangableCase implements DiffCase {
+    accept(target: any[], i: number, name: string): void;
+    /**
+     * When default language source is already compared, it contains diff, e.g.
+     * { __old: value, __new: wert 1 }, if target annotation in other language
+     * has other value, it should also reflect the value, be { __old: value,
+     * __new: wert 2 }, not { __old: value,  __new: wert 1 }. So we remove the
+     * diff completely from value and let it be compared again. Other language
+     * source will be empty anyway.
+     */
+    private getSourceValue;
+    /**
+     * If the array doesn't have any other annotations to take the values from,
+     * we just don't do it and include the annotations from other language as it
+     * is. E.g. we include Label but there are no Heading or QuickInfo to take
+     * values from. So we just don't do it.
+     * @param target where to put the missing item
+     * @param property node name
+     * @returns true if there are some annotations to take the values from.
+     */
+    canAccept(target: any[], property: string): boolean;
+    private interchangableTerms;
+    private findByPriority;
+}

package/dist/annotations/comparator/interchangableCase.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparator_1 = require("./comparator");
+class InterchangableCase {
+    constructor() {
+        // If one of the terms is missing, its values can be filled by others.
+        // Usually Heading or QuickInfo is missing. So we order terms by source
+        // priority (take from label first).
+        this.interchangableTerms = ["SAP__common.Label", "SAP__common.Heading", "SAP__common.QuickInfo"];
+    }
+    accept(target, i, name) {
+        if (name === "Annotation" && this.interchangableTerms.includes(target[i]?._attributes?.Term)) {
+            const source = this.findByPriority(target, i);
+            if (source) {
+                for (const attribute of Object.keys(source._attributes)) {
+                    if (attribute !== "Term") {
+                        const sourceValue = this.getSourceValue(source, attribute);
+                        target[i]._attributes[attribute] = sourceValue;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * When default language source is already compared, it contains diff, e.g.
+     * { __old: value, __new: wert 1 }, if target annotation in other language
+     * has other value, it should also reflect the value, be { __old: value,
+     * __new: wert 2 }, not { __old: value,  __new: wert 1 }. So we remove the
+     * diff completely from value and let it be compared again. Other language
+     * source will be empty anyway.
+     */
+    getSourceValue(source, attribute) {
+        let value = source._attributes[attribute];
+        if (value instanceof comparator_1.Diff) {
+            value = value.__old;
+        }
+        return value;
+    }
+    /**
+     * If the array doesn't have any other annotations to take the values from,
+     * we just don't do it and include the annotations from other language as it
+     * is. E.g. we include Label but there are no Heading or QuickInfo to take
+     * values from. So we just don't do it.
+     * @param target where to put the missing item
+     * @param property node name
+     * @returns true if there are some annotations to take the values from.
+     */
+    canAccept(target, property) {
+        return property === "Annotation" && target
+            .map(item => item._attributes?.Term)
+            .some(term => this.interchangableTerms.includes(term));
+    }
+    findByPriority(annotations, index) {
+        for (const interchangableTerm of this.interchangableTerms) {
+            for (const annotation of annotations) {
+                if (annotation._attributes?.Term === interchangableTerm &&
+                    annotation !== annotations[index]) {
+                    return annotation;
+                }
+            }
+        }
+    }
+}
+exports.default = InterchangableCase;
+//# sourceMappingURL=interchangableCase.js.map

package/dist/annotations/converter/metadataJsonReferenceUtil.d.ts

@@ -0,0 +1,12 @@
+export default class MetadataJsonReferenceUtil {
+    private json;
+    private aliases;
+    private namespaces;
+    constructor(json: any);
+    aliasToNamespace(target: string): string;
+    namespaceToAlias(target: string): string;
+    private convertReference;
+    private getAliases;
+    private getNamespaces;
+    private initReferences;
+}

package/dist/annotations/converter/metadataJsonReferenceUtil.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataJsonUtil_1 = require("./metadataJsonUtil");
+class MetadataJsonReferenceUtil {
+    constructor(json) {
+        this.aliases = null;
+        this.namespaces = null;
+        this.json = json;
+    }
+    aliasToNamespace(target) {
+        return this.convertReference(this.getAliases(), target);
+    }
+    namespaceToAlias(target) {
+        return this.convertReference(this.getNamespaces(), target);
+    }
+    convertReference(references, target) {
+        for (const alias of references.keys()) {
+            target = target.replaceAll(alias + ".", references.get(alias) + ".");
+        }
+        return target;
+    }
+    getAliases() {
+        this.initReferences();
+        return this.aliases;
+    }
+    getNamespaces() {
+        this.initReferences();
+        return this.namespaces;
+    }
+    initReferences() {
+        if (!this.aliases || !this.namespaces) {
+            const references = new Array();
+            for (const ref of metadataJsonUtil_1.default.getReferences(this.json)) {
+                references.push(...ref.includes);
+            }
+            references.push(metadataJsonUtil_1.default.getSchemaReference(this.json));
+            this.aliases = new Map();
+            this.namespaces = new Map();
+            for (const mapping of references) {
+                if (mapping.alias && mapping.namespace) {
+                    const { alias, namespace } = mapping;
+                    this.aliases.set(alias, namespace);
+                    this.namespaces.set(namespace, alias);
+                }
+            }
+        }
+    }
+}
+exports.default = MetadataJsonReferenceUtil;
+//# sourceMappingURL=metadataJsonReferenceUtil.js.map

package/dist/annotations/converter/metadataJsonUtil.d.ts

@@ -0,0 +1,30 @@
+export default class MetadataJsonUtil {
+    static mapAnnotationsPerTarget(json: any): Map<string, IJsonIndex>;
+    static getVersion(json: any): any;
+    static getAnnotations(json: any): any[];
+    static setAnnotations(json: any, annotations: any[]): void;
+    static getSchemaNode(json: any): any;
+    static getSchemaReference(json: any): MetadataInclude;
+    static getEdmx(json: any): any;
+    static getDataServices(json: any): any;
+    static getReferences(json: any): MetadataReference[];
+    static toArrayReadOnly(json: any): any[];
+    static toArrayTransform(json: any, property: string): void;
+}
+export declare class MetadataReference {
+    uri: string;
+    includes: MetadataInclude[];
+    constructor(referenceJson: any);
+    getAlias(namespace: string): string | undefined;
+}
+export declare class MetadataInclude {
+    namespace: string;
+    alias: string;
+    constructor(alias: string, namespace: string);
+    equals(other: MetadataInclude): boolean;
+    static fromJson(json: any): MetadataInclude;
+}
+export interface IJsonIndex {
+    json: any;
+    index: number;
+}