@ui5/task-adaptation 1.2.0 → 1.3.1

package/dist/annotationManager.d.ts

@@ -1,18 +0,0 @@
-import AbapRepoManager from "./repositories/abapRepoManager";
-import { IConfiguration } from "./model/types";
-import Language from "./model/language";
-export interface IAnnotationFiles {
-    annotationName: string;
-    annotationFileName: string;
-}
-export default class AnnotationManager {
-    private abapRepoManager;
-    private configuration;
-    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
-    ANNOTATIONS_FOLDER: string;
-    process(renamedBaseAppManifest: any, languages: Language[]): Promise<Map<string, string>>;
-    private normalizeAppVariantId;
-    private updateManifestModel;
-    private createManifestModel;
-    private enhanceManifestModel;
-}

package/dist/annotationManager.js

@@ -1,80 +0,0 @@
-"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 serviceRequestor_1 = require("./annotations/serviceRequestor");
-const path_1 = require("path");
-const I18N_DEFAULT_PATH = "i18n/annotations";
-const I18N_DEFAULT_MODEL_NAME = "@i18n";
-const SAPUI5 = "sap.ui5";
-class AnnotationManager {
-    constructor(configuration, abapRepoManager) {
-        this.ANNOTATIONS_FOLDER = "annotations";
-        this.configuration = configuration;
-        this.abapRepoManager = abapRepoManager;
-    }
-    async process(renamedBaseAppManifest, languages) {
-        const { id } = baseAppManager_1.default.getIdVersion(renamedBaseAppManifest);
-        baseAppManager_1.default.validateProperty(id, "sap.app/id");
-        const normalisedId = this.normalizeAppVariantId(id);
-        //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 i18nManager = new i18nManager_1.default(modelName, id, languages);
-        const serviceRequestor = new serviceRequestor_1.default(this.configuration, this.abapRepoManager);
-        const dataSourceManager = new dataSourceManager_1.default();
-        dataSourceManager.addDataSources(renamedBaseAppManifest["sap.app"]?.dataSources);
-        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);
-    }
-    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);
-    }
-    createManifestModel(manifest, modelName, uri) {
-        let sapui5 = manifest[SAPUI5] == null ? manifest[SAPUI5] = {} : manifest[SAPUI5];
-        if (sapui5.models == null) {
-            sapui5.models = {};
-        }
-        if (sapui5.models[modelName] == null) {
-            sapui5.models[modelName] = {};
-        }
-        sapui5.models[modelName].type = "sap.ui.model.resource.ResourceModel";
-        if (uri) {
-            sapui5.models[modelName].uri = uri;
-        }
-        return sapui5.models[modelName];
-    }
-    enhanceManifestModel(manifest, modelToEnhance, bundleUrl) {
-        let model = manifest[SAPUI5]?.models[modelToEnhance];
-        if (model) {
-            if (model.settings == null) {
-                model.settings = {};
-            }
-            if (model.settings.enhanceWith == null) {
-                model.settings.enhanceWith = [];
-            }
-            if (model.settings.enhanceWith.every((bundle) => bundle.bundleUrl !== bundleUrl)) {
-                model.settings.enhanceWith.push({
-                    bundleUrl,
-                    bundleUrlRelativeTo: "component"
-                });
-            }
-        }
-        else {
-            this.createManifestModel(manifest, modelToEnhance, bundleUrl);
-        }
-    }
-}
-exports.default = AnnotationManager;
-//# sourceMappingURL=annotationManager.js.map

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

@@ -1,47 +0,0 @@
-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

@@ -1,279 +0,0 @@
-"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++) {
-            // There might be an exceptional case, when the object doesn't
-            // contain attributes. In this case we continue traversing, like
-            // UI5 does.
-            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

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

package/dist/annotations/comparator/diffCase.js

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

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

@@ -1,25 +0,0 @@
-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

@@ -1,65 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,50 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-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;
-}