@ui5/task-adaptation 1.3.0 → 1.3.1

package/dist/annotations/converter/metadataJsonUtil.js

@@ -1,70 +0,0 @@
-export default class MetadataJsonUtil {
-    static mapAnnotationsPerTarget(json) {
-        const annotations = Array.isArray(json) ? json : this.getAnnotations(json);
-        return new Map(annotations.map((json, index) => [json?._attributes?.Target, { json, index }]));
-    }
-    static getVersion(json) {
-        return this.getEdmx(json)?._attributes?.Version;
-    }
-    static getAnnotations(json) {
-        return this.toArrayReadOnly(this.getSchemaNode(json)?.Annotations);
-    }
-    static setAnnotations(json, annotations) {
-        const schema = this.getSchemaNode(json);
-        annotations.forEach(annotation => annotation._attributes.xmlns = "http://docs.oasis-open.org/odata/ns/edm");
-        schema.Annotations = annotations;
-    }
-    static getSchemaNode(json) {
-        return this.getDataServices(json)?.Schema;
-    }
-    static getSchemaReference(json) {
-        return MetadataInclude.fromJson(this.getDataServices(json)?.Schema?._attributes);
-    }
-    static getEdmx(json) {
-        return json["edmx:Edmx"];
-    }
-    static getDataServices(json) {
-        return this.getEdmx(json)["edmx:DataServices"];
-    }
-    static getReferences(json) {
-        const referenceNode = this.toArrayReadOnly(this.getEdmx(json)["edmx:Reference"]);
-        return referenceNode.map(ref => new MetadataReference(ref));
-    }
-    static toArrayReadOnly(json) {
-        return Array.isArray(json) ? json : [json];
-    }
-    static toArrayTransform(json, property) {
-        if (!Array.isArray(json[property])) {
-            json[property] = [json[property]];
-        }
-    }
-}
-export class MetadataReference {
-    uri;
-    includes = new Array();
-    constructor(referenceJson) {
-        this.uri = referenceJson._attributes.Uri;
-        for (const include of MetadataJsonUtil.toArrayReadOnly(referenceJson["edmx:Include"])) {
-            this.includes.push(MetadataInclude.fromJson(include));
-        }
-    }
-    getAlias(namespace) {
-        const include = this.includes.find(include => include.namespace === namespace);
-        return include?.alias;
-    }
-}
-export class MetadataInclude {
-    namespace;
-    alias;
-    constructor(alias, namespace) {
-        this.alias = alias;
-        this.namespace = namespace;
-    }
-    equals(other) {
-        return this.alias === other.alias && this.namespace === other.namespace;
-    }
-    static fromJson(json) {
-        return new MetadataInclude(json?._attributes?.Alias, json?._attributes?.Namespace);
-    }
-}
-//# sourceMappingURL=metadataJsonUtil.js.map

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

@@ -1,21 +0,0 @@
-export default class UI5JsonConverter {
-    config: any;
-    oAnnotationConfig: any;
-    static convertAnnotations(json: any): any[];
-    static processAnnotations(json: any, target: string): any;
-    private static processObject;
-    static processTerms(json: any): any;
-    private static processInlineAnnotationWithCollections;
-    private static isReferenced;
-    private static processAnnotation;
-    private static getInlineAnnotation;
-    private static createTerm;
-    private static processCollection;
-    private static processCollectionItem;
-    private static updateToArray;
-    private static getAttributes;
-    private static trimLeft;
-    private static trimByAt;
-    private static isWrapped;
-    private static getWrappedProperty;
-}

package/dist/annotations/converter/ui5JsonConverter.js

@@ -1,252 +0,0 @@
-import UI5JsonParser from "./ui5MetadataJsonUtil.js";
-export default class UI5JsonConverter {
-    config;
-    oAnnotationConfig;
-    static convertAnnotations(json) {
-        const annotationsNode = UI5JsonParser.getAnnotationsNode(json);
-        if (annotationsNode) {
-            return Object.entries(annotationsNode).map(([target, annotations]) => this.processAnnotations(annotations, target));
-        }
-        return [];
-    }
-    static processAnnotations(json, target) {
-        const attributes = {
-            "_attributes": {
-                "Target": this.trimLeft(target, "@")
-            }
-        };
-        const annotation = this.processTerms(json);
-        return Object.assign(attributes, annotation);
-    }
-    static processObject(term, value) {
-        let wrapped = this.getWrappedProperty(value);
-        if (wrapped) {
-            this.getAttributes(term)[wrapped.property] = wrapped.value;
-        }
-        else {
-            const record = this.processTerms(value);
-            this.updateToArray(term, "Record", record);
-        }
-    }
-    static processTerms(json) {
-        let result = {};
-        const pendingInlineAnnotationKeys = new Array();
-        for (const key of Object.keys(json)) {
-            let wrapped = this.getWrappedProperty(json);
-            const inlineAnnotation = this.getInlineAnnotation(key);
-            if (inlineAnnotation) {
-                pendingInlineAnnotationKeys.push(inlineAnnotation);
-                continue;
-            }
-            if (wrapped) {
-                this.getAttributes(result)[wrapped.property] = wrapped.value;
-            }
-            else if (key.startsWith("$")) {
-                this.getAttributes(result)[this.trimLeft(key, "$")] = json[key];
-            }
-            else {
-                // Split Annotation from PropertyValue
-                const options = (key[0] === "@") ? {
-                    attributesProperty: "Term",
-                    entity: "Annotation"
-                } : {
-                    attributesProperty: "Property",
-                    entity: "PropertyValue",
-                    explicitBoolean: true
-                };
-                const term = this.createTerm(key, options.attributesProperty);
-                const value = json[key];
-                if (typeof value === "string") {
-                    term._attributes.String = value;
-                }
-                else if (typeof value === "boolean" && (!value || options.explicitBoolean)) {
-                    term._attributes.Bool = value.toString();
-                }
-                else if (typeof value === "number") {
-                    term._attributes.Int = value.toString();
-                }
-                else if (Array.isArray(value)) {
-                    this.processCollection(term, value);
-                }
-                else if (typeof value === "object") {
-                    this.processObject(term, value);
-                }
-                this.updateToArray(result, options.entity, term);
-            }
-        }
-        for (const inlineAnnotation of pendingInlineAnnotationKeys) {
-            const { term, reference } = inlineAnnotation;
-            if (inlineAnnotation.isInlineAnnotationWithCollections) {
-                // TODO can possibly be merged with below
-                this.processInlineAnnotationWithCollections(inlineAnnotation, json, result);
-            }
-            else if (Array.isArray(json[inlineAnnotation.key])) {
-                const annotationTerm = { Annotation: this.createTerm(term, "Term") };
-                this.processCollection(annotationTerm.Annotation, json[inlineAnnotation.key]);
-                if (Array.isArray(result[inlineAnnotation.entity])) {
-                    let referenced = result[inlineAnnotation.entity].find((item) => this.isReferenced(item, inlineAnnotation.attributesProperty, reference));
-                    if (referenced) {
-                        referenced = Object.assign(referenced, annotationTerm);
-                    }
-                }
-                else if (result[inlineAnnotation.entity]) {
-                    result[inlineAnnotation.entity] = Object.assign(result[inlineAnnotation.entity], annotationTerm);
-                }
-            }
-            else {
-                const annotation = this.processAnnotation(json, inlineAnnotation.key, term);
-                if (Array.isArray(result[inlineAnnotation.entity])) {
-                    const referenced = result[inlineAnnotation.entity].find((item) => this.isReferenced(item, inlineAnnotation.attributesProperty, reference));
-                    if (referenced) {
-                        referenced.Annotation = annotation;
-                    }
-                }
-                else if (result[inlineAnnotation.entity]) {
-                    result[inlineAnnotation.entity].Annotation = annotation;
-                }
-            }
-        }
-        return result;
-    }
-    static processInlineAnnotationWithCollections(inlineAnnotation, json, result) {
-        delete Object.assign(json, { [`@${inlineAnnotation.term}`]: json[inlineAnnotation.key] })[inlineAnnotation.key];
-        const term = this.createTerm(inlineAnnotation.term, "Term");
-        this.processCollection(term, json[`@${inlineAnnotation.term}`]);
-        const PropertyValue = (Array.isArray(result.PropertyValue)) ? result.PropertyValue : [result.PropertyValue];
-        const targetProperty = PropertyValue.find((propertyValueObject) => {
-            return this.isReferenced(propertyValueObject, "Property", inlineAnnotation.reference);
-        });
-        if (targetProperty) {
-            this.updateToArray(targetProperty, "Annotation", term);
-        }
-    }
-    static isReferenced(item, attributesProperty, reference) {
-        return this.getAttributes(item) && this.getAttributes(item)[attributesProperty] === reference;
-    }
-    static processAnnotation(json, key, term = key) {
-        const annotation = this.processTerms(json[key]);
-        const annotationTerm = this.trimByAt(term);
-        const attributes = this.getAttributes(annotation);
-        if (Object.keys(attributes).length > 0 && annotationTerm) {
-            annotation._attributes = Object.assign({ "Term": annotationTerm }, attributes);
-        }
-        else {
-            this.getAttributes(annotation).Term = annotationTerm;
-        }
-        return annotation;
-    }
-    static getInlineAnnotation(key) {
-        const parts = key.split("@"); // @<ref>@<term>
-        if (parts.length === 3) {
-            return {
-                reference: parts[1],
-                term: parts[2],
-                key,
-                attributesProperty: "Term",
-                entity: "Annotation"
-            };
-        }
-        else if (parts.length === 2 && parts[0]) { // <ref>@<term>
-            return {
-                reference: parts[0],
-                term: parts[1],
-                key,
-                isInlineAnnotationWithCollections: true,
-                attributesProperty: "Property",
-                entity: "PropertyValue",
-            };
-        }
-    }
-    static createTerm(key, attributesProperty) {
-        const parts = key.split("#");
-        const qualifier = parts.length > 1 && parts.pop();
-        const term = {
-            "_attributes": {
-                [attributesProperty]: this.trimByAt(parts[0])
-            }
-        };
-        if (qualifier) {
-            term._attributes.Qualifier = qualifier;
-        }
-        return term;
-    }
-    static processCollection(term, value) {
-        const collection = term.Collection = {};
-        for (const item of value) {
-            this.processCollectionItem(collection, item);
-        }
-    }
-    static processCollectionItem(collection, item) {
-        let wrapped = this.getWrappedProperty(item);
-        if (wrapped) {
-            this.updateToArray(collection, wrapped.property, wrapped.value.length > 0 ? { _text: wrapped.value } : {});
-        }
-        else if (typeof item === "string") {
-            this.updateToArray(collection, "String", { _text: item });
-        }
-        else if (typeof item === "object") {
-            this.processObject(collection, item);
-        }
-    }
-    static updateToArray(object, key, value) {
-        if (object[key]) {
-            if (!Array.isArray(object[key])) {
-                object[key] = [object[key]];
-            }
-            object[key].push(value);
-        }
-        else {
-            object[key] = value;
-        }
-    }
-    static getAttributes(parent) {
-        if (parent._attributes == null) {
-            parent._attributes = {};
-        }
-        return parent._attributes;
-    }
-    static trimLeft(str, char) {
-        while (str.startsWith(char)) {
-            str = str.substring(1);
-        }
-        return str;
-    }
-    static trimByAt(term) {
-        const indexOfAt = term.indexOf("@");
-        if (indexOfAt > -1) {
-            return term.substring(indexOfAt + 1);
-        }
-        return term;
-    }
-    static isWrapped(type) {
-        // copied from openUI5 _MetadataConverter.js
-        switch (type) {
-            case "$AnnotationPath":
-            case "$NavigationPropertyPath":
-            case "$Path":
-            case "$PropertyPath":
-            case "$Binary":
-            case "$Date":
-            case "$DateTimeOffset":
-            case "$Decimal":
-            case "$Duration":
-            case "$Guid":
-            case "$TimeOfDay":
-            case "$UrlRef":
-            case "$EnumMember":
-                return true;
-        }
-    }
-    static getWrappedProperty(item) {
-        if (typeof item === "object") {
-            const keys = Object.keys(item);
-            if (keys.length === 1 && this.isWrapped(keys[0])) {
-                return {
-                    property: keys[0].substring(1),
-                    value: item[keys[0]]
-                };
-            }
-        }
-    }
-}
-//# sourceMappingURL=ui5JsonConverter.js.map

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

@@ -1,3 +0,0 @@
-export default class UI5MetadataJsonUtil {
-    static getAnnotationsNode(json: any): any;
-}

package/dist/annotations/converter/ui5MetadataJsonUtil.js

@@ -1,10 +0,0 @@
-export default class UI5MetadataJsonUtil {
-    static getAnnotationsNode(json) {
-        for (const key of Object.keys(json)) {
-            if (json[key].$kind === "Schema") {
-                return json[key].$Annotations;
-            }
-        }
-    }
-}
-//# sourceMappingURL=ui5MetadataJsonUtil.js.map

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

@@ -1,5 +0,0 @@
-export default class UI5XmlConverter {
-    static convertV2(xml: string): any;
-    static convertV4(xml: string): any;
-    private static getDocument;
-}

package/dist/annotations/converter/ui5XmlConverter.js

@@ -1,14 +0,0 @@
-import { V2MetadataConverter, V4MetadataConverter } from "../../../dist/bundle.js";
-import { JSDOM } from "jsdom";
-export default class UI5XmlConverter {
-    static convertV2(xml) {
-        return new V2MetadataConverter().convertXMLMetadata(this.getDocument(xml));
-    }
-    static convertV4(xml) {
-        return new V4MetadataConverter().convertXMLMetadata(this.getDocument(xml));
-    }
-    static getDocument(xml) {
-        return (new JSDOM(xml, { contentType: "application/xml" })).window._document;
-    }
-}
-//# sourceMappingURL=ui5XmlConverter.js.map

package/dist/annotations/dataSource/dataSource.d.ts

@@ -1,34 +0,0 @@
-import I18nManager from "../../i18nManager.js";
-import { IAnnotationDownloadParams } from "./dataSourceOData.js";
-import Language from "../../model/language.js";
-import ServiceRequestor from "../serviceRequestor.js";
-import Transformer from "../transformers/transformer.js";
-export default class DataSource {
-    protected name: string;
-    private uri;
-    protected jsonTransformers: Transformer[];
-    constructor(name: string, uri: string);
-    /**
-     * Update the json of the dataSources in manifest.json
-     */
-    updateManifest(_: any): void;
-    /**
-     * Get the filename under which it should be stored in dist folder
-     */
-    getFilename(): string;
-    createAnnotationFile(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<{
-        filename: string;
-        xml: string;
-    }>;
-    /**
-     * Download the annotation for all configured languages
-     * @param languages from configuration
-     * @param serviceRequestor will download the annotation for all languages
-     */
-    private getPromisesPerLanguage;
-    /**
-     * Download annotations and process xml string after it
-     */
-    downloadAnnotation(language: Language, serviceRequestor: ServiceRequestor): Promise<any>;
-    afterXmlDownload({ xml, language, serviceRequestor, uri }: IAnnotationDownloadParams): Promise<any>;
-}

package/dist/annotations/dataSource/dataSource.js

@@ -1,62 +0,0 @@
-import XmlUtil from "../../util/xmlUtil.js";
-export default class DataSource {
-    name;
-    uri;
-    jsonTransformers = new Array();
-    constructor(name, uri) {
-        this.name = name;
-        this.uri = uri;
-    }
-    /**
-     * Update the json of the dataSources in manifest.json
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    updateManifest(_) {
-        // to be overriden in children
-    }
-    /**
-     * Get the filename under which it should be stored in dist folder
-     */
-    getFilename() {
-        return `annotations/annotation_${this.name}.xml`;
-    }
-    async createAnnotationFile(languages, i18nManager, serviceRequestor) {
-        const annotationJsons = this.getPromisesPerLanguage(languages, serviceRequestor);
-        const annotationJson = await i18nManager.populateTranslations(annotationJsons);
-        const xml = XmlUtil.jsonToXml(await annotationJson.json);
-        return {
-            filename: this.getFilename(),
-            xml
-        };
-    }
-    /**
-     * Download the annotation for all configured languages
-     * @param languages from configuration
-     * @param serviceRequestor will download the annotation for all languages
-     */
-    getPromisesPerLanguage(languages, serviceRequestor) {
-        const promises = new Map();
-        for (const language of languages) {
-            promises.set(language, this.downloadAnnotation(language, serviceRequestor));
-        }
-        return promises;
-    }
-    /**
-     * Download annotations and process xml string after it
-     */
-    async downloadAnnotation(language, serviceRequestor) {
-        const languageXmlContent = await serviceRequestor.downloadAnnotation(this.uri, this.name, language);
-        if (!languageXmlContent) {
-            throw new Error(`Xml is undefined for '${this.uri}', name '${this.name}' and language '${language.sap}'`);
-        }
-        return this.afterXmlDownload({ xml: languageXmlContent, language, serviceRequestor, uri: this.uri });
-    }
-    async afterXmlDownload({ xml, language, serviceRequestor, uri }) {
-        let json = XmlUtil.xmlToJson(xml);
-        for (const transformer of this.jsonTransformers) {
-            json = await transformer.transform({ xml, json, language, serviceRequestor, uri });
-        }
-        return json;
-    }
-}
-//# sourceMappingURL=dataSource.js.map

package/dist/annotations/dataSource/dataSourceManager.d.ts

@@ -1,12 +0,0 @@
-import I18nManager from "../../i18nManager.js";
-import Language from "../../model/language.js";
-import ServiceRequestor from "../serviceRequestor.js";
-export default class DataSourceManager {
-    private dataSources;
-    /**
-     * Parses dataSources from manifest.json.
-     * @param dataSourcesJson manifest.json/sap.app/dataSources node
-     */
-    addDataSources(dataSourcesJson: any): void;
-    createAnnotationFiles(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<Map<string, string>>;
-}

package/dist/annotations/dataSource/dataSourceManager.js

@@ -1,45 +0,0 @@
-import DataSourceOData from "./dataSourceOData.js";
-import DataSourceODataAnnotation from "./dataSourceODataAnnotation.js";
-import path from "path/posix";
-export default class DataSourceManager {
-    dataSources = new Array();
-    /**
-     * Parses dataSources from manifest.json.
-     * @param dataSourcesJson manifest.json/sap.app/dataSources node
-     */
-    addDataSources(dataSourcesJson) {
-        if (!dataSourcesJson) {
-            return;
-        }
-        const odataAnnotationMap = new Map();
-        // Loop over OData first to collect linked annotation names
-        for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            if (dataSource.uri?.startsWith("/") && dataSource.type === "OData") {
-                const uri = path.normalize(dataSource.uri + "/$metadata");
-                const odata = new DataSourceOData(name, uri, dataSource);
-                odata.getAnnotations().forEach(annotation => odataAnnotationMap.set(annotation, uri));
-                this.dataSources.push(odata);
-            }
-        }
-        // If ODataAnnotation is in OData annotations, pass metadata url to it
-        for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            const uri = dataSource.uri;
-            const metadataUrl = odataAnnotationMap.get(name);
-            if (uri?.startsWith("/") && dataSource.type === "ODataAnnotation") {
-                this.dataSources.push(new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl));
-            }
-        }
-        for (const dataSource of this.dataSources) {
-            dataSource.updateManifest(dataSourcesJson);
-        }
-    }
-    async createAnnotationFiles(languages, i18nManager, serviceRequestor) {
-        const annotationFiles = new Map();
-        for (const dataSource of this.dataSources) {
-            const { filename, xml } = await dataSource.createAnnotationFile(languages, i18nManager, serviceRequestor);
-            annotationFiles.set(filename, xml);
-        }
-        return annotationFiles;
-    }
-}
-//# sourceMappingURL=dataSourceManager.js.map

package/dist/annotations/dataSource/dataSourceOData.d.ts

@@ -1,17 +0,0 @@
-import DataSource from "./dataSource.js";
-import Language from "../../model/language.js";
-import ServiceRequestor from "../serviceRequestor.js";
-export interface IAnnotationDownloadParams {
-    uri: string;
-    xml: string;
-    language: Language;
-    serviceRequestor: ServiceRequestor;
-}
-export default class DataSourceOData extends DataSource {
-    private dataSourceJson;
-    constructor(name: string, uri: string, dataSourceJson: any);
-    updateManifest(manifestDataSources: any): void;
-    addNewODataAnnotation(manifestDataSources: any): void;
-    private getSettings;
-    getAnnotations(): string[];
-}

package/dist/annotations/dataSource/dataSourceOData.js

@@ -1,45 +0,0 @@
-import ConvertV2ToV4 from "../transformers/convertV2ToV4.js";
-import DataSource from "./dataSource.js";
-import MakeAnnotationNamespaceUnique from "../transformers/makeAnnotationNamespaceUnique.js";
-import RemoveAllSchemaNodesExceptAnnotations from "../transformers/removeAllSchemaNodesExceptAnnotations.js";
-import TraverseReferences from "../transformers/traverseReferences.js";
-import { getUniqueName } from "../../util/commonUtil.js";
-export default class DataSourceOData extends DataSource {
-    dataSourceJson;
-    constructor(name, uri, dataSourceJson) {
-        super(name, uri);
-        this.dataSourceJson = dataSourceJson;
-        this.jsonTransformers = [
-            new TraverseReferences(),
-            new ConvertV2ToV4(),
-            new RemoveAllSchemaNodesExceptAnnotations(),
-            new MakeAnnotationNamespaceUnique()
-        ];
-    }
-    updateManifest(manifestDataSources) {
-        this.getSettings().ignoreAnnotationsFromMetadata = true;
-        this.addNewODataAnnotation(manifestDataSources);
-    }
-    addNewODataAnnotation(manifestDataSources) {
-        const newAnnotationNameTemplate = `annotation_${this.name}`;
-        let newAnnotationName = getUniqueName(Object.keys(manifestDataSources), newAnnotationNameTemplate);
-        this.getAnnotations().unshift(newAnnotationName);
-        manifestDataSources[newAnnotationName] = {
-            type: "ODataAnnotation",
-            uri: this.getFilename()
-        };
-    }
-    getSettings() {
-        if (this.dataSourceJson.settings == null) {
-            this.dataSourceJson.settings = {};
-        }
-        return this.dataSourceJson.settings;
-    }
-    getAnnotations() {
-        if (this.getSettings().annotations == null) {
-            this.getSettings().annotations = [];
-        }
-        return this.getSettings().annotations;
-    }
-}
-//# sourceMappingURL=dataSourceOData.js.map

package/dist/annotations/dataSource/dataSourceODataAnnotation.d.ts

@@ -1,6 +0,0 @@
-import DataSource from "./dataSource.js";
-export default class DataSourceODataAnnotation extends DataSource {
-    private dataSourceJson;
-    constructor(name: string, uri: string, dataSourceJson: any, metadataUrl: string | undefined);
-    updateManifest(): void;
-}

package/dist/annotations/dataSource/dataSourceODataAnnotation.js

@@ -1,16 +0,0 @@
-import DataSource from "./dataSource.js";
-import TraverseReferences from "../transformers/traverseReferences.js";
-export default class DataSourceODataAnnotation extends DataSource {
-    dataSourceJson;
-    constructor(name, uri, dataSourceJson, metadataUrl) {
-        super(name, uri);
-        this.dataSourceJson = dataSourceJson;
-        this.jsonTransformers = [
-            new TraverseReferences(metadataUrl)
-        ];
-    }
-    updateManifest() {
-        this.dataSourceJson.uri = this.getFilename();
-    }
-}
-//# sourceMappingURL=dataSourceODataAnnotation.js.map

package/dist/annotations/serviceRequestor.d.ts

@@ -1,9 +0,0 @@
-import AbapRepoManager from "../repositories/abapRepoManager.js";
-import { IConfiguration } from "../model/types.js";
-import Language from "../model/language.js";
-export default class ServiceRequestor {
-    private abapRepoManager;
-    private configuration;
-    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
-    downloadAnnotation(uri: string, name: string, language: Language): Promise<string>;
-}