@sap-ux/adp-tooling 0.8.11 → 0.9.0

package/dist/writer/changes/writers/annotations-writer.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationsWriter = void 0;
+const path_1 = __importDefault(require("path"));
+const change_utils_1 = require("../../../base/change-utils");
+/**
+ * Handles the creation and writing of annotations data changes for a project.
+ */
+class AnnotationsWriter {
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs, projectPath) {
+        this.fs = fs;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Constructs the content for an annotation change based on provided data.
+     *
+     * @param {AnnotationsData} data - The data object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the annotation change.
+     */
+    constructContent(data) {
+        const { isInternalUsage, annotation: { dataSource, fileName } } = data;
+        const annotationFileNameWithoutExtension = fileName === null || fileName === void 0 ? void 0 : fileName.toLocaleLowerCase().replace('.xml', '');
+        const annotationNameSpace = isInternalUsage
+            ? `annotation.${annotationFileNameWithoutExtension}`
+            : `customer.annotation.${annotationFileNameWithoutExtension}`;
+        return {
+            dataSourceId: `${dataSource}`,
+            annotations: [annotationNameSpace],
+            annotationsInsertPosition: 'END',
+            dataSource: {
+                [annotationNameSpace]: {
+                    uri: `../annotations/${fileName}`,
+                    type: 'ODataAnnotation'
+                }
+            }
+        };
+    }
+    /**
+     * Determines the appropriate filename for the annotation file based on user answers.
+     *
+     * @param {AnnotationsData} data - The answers object containing user choices.
+     * @returns {string | undefined} The determined filename for the annotation file.
+     */
+    getAnnotationFileName({ annotation }) {
+        return annotation.filePath ? path_1.default.basename(annotation.filePath) : `annotation_${Date.now()}.xml`;
+    }
+    /**
+     * Writes the annotation change to the project based on the provided data.
+     *
+     * @param {AnnotationsData} data - The annotations data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            data.annotation.fileName = this.getAnnotationFileName(data);
+            const content = this.constructContent(data);
+            const change = (0, change_utils_1.getGenericChange)(data, content, "appdescr_app_addAnnotationsToOData" /* ChangeType.ADD_ANNOTATIONS_TO_ODATA */);
+            (0, change_utils_1.writeAnnotationChange)(this.projectPath, data, change, this.fs);
+        });
+    }
+}
+exports.AnnotationsWriter = AnnotationsWriter;
+//# sourceMappingURL=annotations-writer.js.map

package/dist/writer/changes/writers/component-usages-writer.d.ts

@@ -0,0 +1,36 @@
+import type { Editor } from 'mem-fs-editor';
+import type { IWriter, ComponentUsagesData } from '../../../types';
+/**
+ * Handles the creation and writing of component usages data changes for a project.
+ */
+export declare class ComponentUsagesWriter implements IWriter<ComponentUsagesData> {
+    private fs;
+    private projectPath;
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs: Editor, projectPath: string);
+    /**
+     * Constructs the content for an component usages change based on provided data.
+     *
+     * @param {ComponentUsagesData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the component usages change.
+     */
+    private constructContent;
+    /**
+     * Constructs the content for an library reference change based on provided data.
+     *
+     * @param {ComponentUsagesData} data - The answers object containing information needed to construct the content property.
+     * @returns {object | undefined} The constructed content object for the library reference change.
+     */
+    private constructLibContent;
+    /**
+     * Writes the component usages change to the project based on the provided data.
+     *
+     * @param {ComponentUsagesData} data - The component usages data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data: ComponentUsagesData): Promise<void>;
+}
+//# sourceMappingURL=component-usages-writer.d.ts.map

package/dist/writer/changes/writers/component-usages-writer.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentUsagesWriter = void 0;
+const change_utils_1 = require("../../../base/change-utils");
+/**
+ * Handles the creation and writing of component usages data changes for a project.
+ */
+class ComponentUsagesWriter {
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs, projectPath) {
+        this.fs = fs;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Constructs the content for an component usages change based on provided data.
+     *
+     * @param {ComponentUsagesData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the component usages change.
+     */
+    constructContent({ component }) {
+        const { data, usageId, settings, isLazy } = component;
+        const componentUsages = {
+            [usageId]: {
+                name: usageId,
+                lazy: isLazy === 'true',
+                settings: (0, change_utils_1.parseStringToObject)(settings),
+                data: (0, change_utils_1.parseStringToObject)(data)
+            }
+        };
+        return {
+            componentUsages
+        };
+    }
+    /**
+     * Constructs the content for an library reference change based on provided data.
+     *
+     * @param {ComponentUsagesData} data - The answers object containing information needed to construct the content property.
+     * @returns {object | undefined} The constructed content object for the library reference change.
+     */
+    constructLibContent(data) {
+        const library = data.library;
+        if (!library.reference) {
+            return undefined;
+        }
+        return {
+            libraries: {
+                [library.reference]: {
+                    lazy: library.referenceIsLazy === 'true'
+                }
+            }
+        };
+    }
+    /**
+     * Writes the component usages change to the project based on the provided data.
+     *
+     * @param {ComponentUsagesData} data - The component usages data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const componentUsagesContent = this.constructContent(data);
+            const libRefContent = this.constructLibContent(data);
+            const shouldAddLibRef = libRefContent !== undefined;
+            const compUsagesChange = (0, change_utils_1.getGenericChange)(data, componentUsagesContent, "appdescr_ui5_addComponentUsages" /* ChangeType.ADD_COMPONENT_USAGES */);
+            (0, change_utils_1.writeChangeToFolder)(this.projectPath, compUsagesChange, `id_${data.timestamp}_addComponentUsages.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+            if (shouldAddLibRef) {
+                data.timestamp += 1;
+                const refLibChange = (0, change_utils_1.getGenericChange)(data, libRefContent, "appdescr_ui5_addLibraries" /* ChangeType.ADD_LIBRARY_REFERENCE */);
+                (0, change_utils_1.writeChangeToFolder)(this.projectPath, refLibChange, `id_${data.timestamp}_addLibraries.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+            }
+        });
+    }
+}
+exports.ComponentUsagesWriter = ComponentUsagesWriter;
+//# sourceMappingURL=component-usages-writer.js.map

package/dist/writer/changes/writers/data-source-writer.d.ts

@@ -0,0 +1,31 @@
+import type { Editor } from 'mem-fs-editor';
+import type { IWriter, DataSourceData } from '../../../types';
+/**
+ * Handles the creation and writing of data source data changes for a project.
+ */
+export declare class DataSourceWriter implements IWriter<DataSourceData> {
+    private fs;
+    private projectPath;
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs: Editor, projectPath: string);
+    /**
+     * Constructs content for a data source change.
+     *
+     * @param {string} dataSourceId - The ID of the data source being modified.
+     * @param {string} dataSourceUri - The new URI to update the data source with.
+     * @param {number} [maxAge] - Optional maximum age.
+     * @returns {object} The constructed content object for the change data source change.
+     */
+    private constructContent;
+    /**
+     * Writes the change data source change to the project based on the provided data.
+     *
+     * @param {DataSourceData} data - The change data source data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data: DataSourceData): Promise<void>;
+}
+//# sourceMappingURL=data-source-writer.d.ts.map

package/dist/writer/changes/writers/data-source-writer.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceWriter = void 0;
+const change_utils_1 = require("../../../base/change-utils");
+/**
+ * Handles the creation and writing of data source data changes for a project.
+ */
+class DataSourceWriter {
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs, projectPath) {
+        this.fs = fs;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Constructs content for a data source change.
+     *
+     * @param {string} dataSourceId - The ID of the data source being modified.
+     * @param {string} dataSourceUri - The new URI to update the data source with.
+     * @param {number} [maxAge] - Optional maximum age.
+     * @returns {object} The constructed content object for the change data source change.
+     */
+    constructContent(dataSourceId, dataSourceUri, maxAge) {
+        const content = {
+            dataSourceId: dataSourceId,
+            entityPropertyChange: [
+                {
+                    propertyPath: 'uri',
+                    operation: 'UPDATE',
+                    propertyValue: dataSourceUri
+                }
+            ]
+        };
+        if (maxAge) {
+            content.entityPropertyChange.push({
+                propertyPath: 'settings/maxAge',
+                operation: 'UPSERT',
+                propertyValue: Number(maxAge)
+            });
+        }
+        return content;
+    }
+    /**
+     * Writes the change data source change to the project based on the provided data.
+     *
+     * @param {DataSourceData} data - The change data source data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dataSourcesDictionary, service } = data;
+            const content = this.constructContent(service.name, service.uri, service.maxAge);
+            const change = (0, change_utils_1.getGenericChange)(data, content, "appdescr_app_changeDataSource" /* ChangeType.CHANGE_DATA_SOURCE */);
+            (0, change_utils_1.writeChangeToFolder)(this.projectPath, change, `id_${data.timestamp}_changeDataSource.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+            const shouldAddAnnotation = service.annotationUri && service.annotationUri.length > 0;
+            if (shouldAddAnnotation) {
+                data.timestamp += 1;
+                const annotationContent = this.constructContent(dataSourcesDictionary[service.name], service.annotationUri);
+                const annotationChange = (0, change_utils_1.getGenericChange)(data, annotationContent, "appdescr_app_changeDataSource" /* ChangeType.CHANGE_DATA_SOURCE */);
+                (0, change_utils_1.writeChangeToFolder)(this.projectPath, annotationChange, `id_${data.timestamp}_changeDataSource.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+            }
+        });
+    }
+}
+exports.DataSourceWriter = DataSourceWriter;
+//# sourceMappingURL=data-source-writer.js.map

package/dist/writer/changes/writers/inbound-writer.d.ts

@@ -0,0 +1,45 @@
+import type { Editor } from 'mem-fs-editor';
+import type { IWriter, InboundData } from '../../../types';
+/**
+ * Handles the creation and writing of inbound data changes for a project.
+ */
+export declare class InboundWriter implements IWriter<InboundData> {
+    private fs;
+    private projectPath;
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs: Editor, projectPath: string);
+    /**
+     * Constructs the content for an inbound data change based on provided data.
+     *
+     * @param {InboundData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the inbound data change.
+     */
+    private constructContent;
+    /**
+     * Enhances the provided content object based on the values provided in answers.
+     *
+     * @param {InboundData} data - An object containing potential values for title, subTitle, and icon.
+     * @param {InboundContent} content - The initial content object to be enhanced.
+     * @returns {void}
+     */
+    private getEnhancedContent;
+    /**
+     * Processes the provided answers object to parse its properties into the correct format.
+     *
+     * @param {InboundData} data - An object containing raw answers for inboundId, title, subTitle, and icon.
+     * @returns {InboundData} A new answers object with properties modified
+     *                           to ensure they are in the correct format for use in content construction.
+     */
+    private getModifiedData;
+    /**
+     * Writes the inbound data change to the project based on the provided data.
+     *
+     * @param {InboundData} data - The inbound data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data: InboundData): Promise<void>;
+}
+//# sourceMappingURL=inbound-writer.d.ts.map

package/dist/writer/changes/writers/inbound-writer.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboundWriter = void 0;
+const change_utils_1 = require("../../../base/change-utils");
+/**
+ * Handles the creation and writing of inbound data changes for a project.
+ */
+class InboundWriter {
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs, projectPath) {
+        this.fs = fs;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Constructs the content for an inbound data change based on provided data.
+     *
+     * @param {InboundData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the inbound data change.
+     */
+    constructContent(data) {
+        const content = {
+            inboundId: data.inboundId,
+            entityPropertyChange: []
+        };
+        this.getEnhancedContent(data, content);
+        return content;
+    }
+    /**
+     * Enhances the provided content object based on the values provided in answers.
+     *
+     * @param {InboundData} data - An object containing potential values for title, subTitle, and icon.
+     * @param {InboundContent} content - The initial content object to be enhanced.
+     * @returns {void}
+     */
+    getEnhancedContent(data, content) {
+        const { icon, title, subTitle } = data.flp;
+        if (title) {
+            content.entityPropertyChange.push({
+                propertyPath: 'title',
+                operation: 'UPSERT',
+                propertyValue: title
+            });
+        }
+        if (subTitle) {
+            content.entityPropertyChange.push({
+                propertyPath: 'subTitle',
+                operation: 'UPSERT',
+                propertyValue: subTitle
+            });
+        }
+        if (icon) {
+            content.entityPropertyChange.push({
+                propertyPath: 'icon',
+                operation: 'UPSERT',
+                propertyValue: icon
+            });
+        }
+    }
+    /**
+     * Processes the provided answers object to parse its properties into the correct format.
+     *
+     * @param {InboundData} data - An object containing raw answers for inboundId, title, subTitle, and icon.
+     * @returns {InboundData} A new answers object with properties modified
+     *                           to ensure they are in the correct format for use in content construction.
+     */
+    getModifiedData(data) {
+        const { title, subTitle, icon } = data.flp;
+        return Object.assign(Object.assign({}, data), { flp: {
+                title: (0, change_utils_1.getParsedPropertyValue)(title),
+                subTitle: (0, change_utils_1.getParsedPropertyValue)(subTitle),
+                icon: (0, change_utils_1.getParsedPropertyValue)(icon)
+            } });
+    }
+    /**
+     * Writes the inbound data change to the project based on the provided data.
+     *
+     * @param {InboundData} data - The inbound data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const answers = this.getModifiedData(data);
+            const { changeWithInboundId, filePath } = (0, change_utils_1.findChangeWithInboundId)(this.projectPath, answers.inboundId);
+            if (!changeWithInboundId) {
+                const content = this.constructContent(answers);
+                const change = (0, change_utils_1.getGenericChange)(data, content, "appdescr_app_changeInbound" /* ChangeType.CHANGE_INBOUND */);
+                (0, change_utils_1.writeChangeToFolder)(this.projectPath, change, `id_${data.timestamp}_changeInbound.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+            }
+            else {
+                if (changeWithInboundId.content) {
+                    this.getEnhancedContent(answers, changeWithInboundId.content);
+                }
+                (0, change_utils_1.writeChangeToFile)(filePath, changeWithInboundId, this.fs);
+            }
+        });
+    }
+}
+exports.InboundWriter = InboundWriter;
+//# sourceMappingURL=inbound-writer.js.map

package/dist/writer/changes/writers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './annotations-writer';
+export * from './component-usages-writer';
+export * from './data-source-writer';
+export * from './inbound-writer';
+export * from './new-model-writer';
+//# sourceMappingURL=index.d.ts.map

package/dist/writer/changes/writers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./annotations-writer"), exports);
+__exportStar(require("./component-usages-writer"), exports);
+__exportStar(require("./data-source-writer"), exports);
+__exportStar(require("./inbound-writer"), exports);
+__exportStar(require("./new-model-writer"), exports);
+//# sourceMappingURL=index.js.map

package/dist/writer/changes/writers/new-model-writer.d.ts

@@ -0,0 +1,29 @@
+import type { Editor } from 'mem-fs-editor';
+import type { IWriter, NewModelData } from '../../../types';
+/**
+ * Handles the creation and writing of new sapui5 model data changes for a project.
+ */
+export declare class NewModelWriter implements IWriter<NewModelData> {
+    private fs;
+    private projectPath;
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs: Editor, projectPath: string);
+    /**
+     * Constructs the content for an new model change based on provided data.
+     *
+     * @param {NewModelData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the new model change.
+     */
+    private constructContent;
+    /**
+     * Writes the new model change to the project based on the provided data.
+     *
+     * @param {NewModelData} data - The new model data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data: NewModelData): Promise<void>;
+}
+//# sourceMappingURL=new-model-writer.d.ts.map

package/dist/writer/changes/writers/new-model-writer.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewModelWriter = void 0;
+const change_utils_1 = require("../../../base/change-utils");
+/**
+ * Handles the creation and writing of new sapui5 model data changes for a project.
+ */
+class NewModelWriter {
+    /**
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The root path of the project.
+     */
+    constructor(fs, projectPath) {
+        this.fs = fs;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Constructs the content for an new model change based on provided data.
+     *
+     * @param {NewModelData} data - The answers object containing information needed to construct the content property.
+     * @returns {object} The constructed content object for the new model change.
+     */
+    constructContent({ service, annotation, addAnnotationMode }) {
+        const content = {
+            dataSource: {
+                [service.name]: {
+                    uri: service.uri,
+                    type: 'OData',
+                    settings: {
+                        version: service.version
+                    }
+                }
+            },
+            model: {
+                [service.modelName]: {
+                    dataSource: service.name
+                }
+            }
+        };
+        if (service.modelSettings && service.modelSettings.length !== 0) {
+            content.model[service.modelName].settings = (0, change_utils_1.parseStringToObject)(service.modelSettings);
+        }
+        if (addAnnotationMode) {
+            content.dataSource[service.name].settings.annotations = [`${annotation.dataSourceName}`];
+            content.dataSource[annotation.dataSourceName] = {
+                uri: annotation.dataSourceURI,
+                type: 'ODataAnnotation'
+            };
+            if (annotation.settings && annotation.settings.length !== 0) {
+                content.dataSource[annotation.dataSourceName].settings = (0, change_utils_1.parseStringToObject)(annotation.settings);
+            }
+        }
+        return content;
+    }
+    /**
+     * Writes the new model change to the project based on the provided data.
+     *
+     * @param {NewModelData} data - The new model data containing all the necessary information to construct and write the change.
+     * @returns {Promise<void>} A promise that resolves when the change writing process is completed.
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = this.constructContent(data);
+            const change = (0, change_utils_1.getGenericChange)(data, content, "appdescr_ui5_addNewModel" /* ChangeType.ADD_NEW_MODEL */);
+            (0, change_utils_1.writeChangeToFolder)(this.projectPath, change, `id_${data.timestamp}_addNewModel.change`, this.fs, "manifest" /* FolderTypes.MANIFEST */);
+        });
+    }
+}
+exports.NewModelWriter = NewModelWriter;
+//# sourceMappingURL=new-model-writer.js.map

package/dist/writer/editors.d.ts

@@ -0,0 +1,18 @@
+import { type Editor } from 'mem-fs-editor';
+import type { GeneratorData, ChangeType } from '../types';
+/**
+ * Generates and applies changes to a project based on a specified generator type.
+ *
+ * This function initializes the file system editor if not provided, selects the appropriate writer based on the generator type,
+ * and then invokes the writer's write method to apply changes. The changes are made in-memory and need to be committed
+ * to be reflected on the disk.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {T} type - The type of generator.
+ * @param {GeneratorData<T>} data - The data specific to the type of generator, containing information necessary for making changes.
+ * @param {Editor | null} [fs] - The `mem-fs-editor` instance used for file operations.
+ * @returns {Promise<Editor>} A promise that resolves to the mem-fs editor instance used for making changes, allowing for further operations or committing changes to disk.
+ * @template T - A type parameter extending `ChangeType`, ensuring the function handles a defined set of generator types.
+ */
+export declare function generateChange<T extends ChangeType>(projectPath: string, type: T, data: GeneratorData<T>, fs?: Editor | null): Promise<Editor>;
+//# sourceMappingURL=editors.d.ts.map