@sap-ux/adp-tooling 0.8.11 → 0.9.1

package/dist/base/change-utils.d.ts

@@ -0,0 +1,90 @@
+import type { Editor } from 'mem-fs-editor';
+import type { AdpProjectData, AnnotationsData, ChangeType, InboundContent, ManifestChangeProperties, PropertyValueType } from '../types';
+type InboundChangeData = {
+    filePath: string;
+    changeWithInboundId: InboundChange | undefined;
+};
+interface InboundChange extends ManifestChangeProperties {
+    content: InboundContent;
+}
+/**
+ * Writes annotation changes to the specified project path using the provided `mem-fs-editor` instance.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {AnnotationsData} data - The data object containing information about the annotation change.
+ * @param {ManifestChangeProperties} change - The annotation data change that will be written.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ * @returns {void}
+ */
+export declare function writeAnnotationChange(projectPath: string, data: AnnotationsData, change: ManifestChangeProperties, fs: Editor): void;
+/**
+ * Writes a given change object to a file within a specified folder in the project's 'changes' directory.
+ * If an additional subdirectory is specified, the change file is written there.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {ManifestChangeProperties} change - The change data to be written to the file.
+ * @param {string} fileName - The name of the file to write the change data to.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ * @param {string} [dir] - An optional subdirectory within the 'changes' directory where the file will be written.
+ * @returns {void}
+ */
+export declare function writeChangeToFolder(projectPath: string, change: ManifestChangeProperties, fileName: string, fs: Editor, dir?: string): void;
+/**
+ * Writes a given change object to a specific file path. The change data is stringified to JSON format before
+ * writing. This function is used to directly write changes to a file, without specifying a directory.
+ *
+ * @param {string} path - The root path of the project.
+ * @param {ManifestChangeProperties} change - The change data to be written to the file.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ */
+export declare function writeChangeToFile(path: string, change: ManifestChangeProperties, fs: Editor): void;
+/**
+ * Parses a string into an object.
+ *
+ * @param {string} str - The string to be parsed into an object. The string should be in the format of object properties without the surrounding braces.
+ * @returns {{ [key: string]: string }} An object constructed from the input string.
+ * @example
+ * // returns { name: "value" }
+ * parseStringToObject('"name":"value"');
+ */
+export declare function parseStringToObject(str: string): {
+    [key: string]: string;
+};
+/**
+ * Attempts to parse a property value as JSON.
+ *
+ * @param {string} propertyValue - The property value to be parsed.
+ * @returns {PropertyValueType} The parsed value if `propertyValue` is valid JSON; otherwise, returns the original `propertyValue`.
+ * @example
+ * // Returns the object { key: "value" }
+ * getParsedPropertyValue('{"key": "value"}');
+ *
+ * // Returns the string "nonJSONValue" because it cannot be parsed as JSON
+ * getParsedPropertyValue('nonJSONValue');
+ */
+export declare function getParsedPropertyValue(propertyValue: PropertyValueType): PropertyValueType;
+/**
+ * Searches for a change file with a specific inbound ID within a project's change directory.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {string} inboundId - The inbound ID to search for within change files.
+ * @returns {InboundChangeData} An object containing the file path and the change object with the matching inbound ID.
+ * @throws {Error} Throws an error if the change file cannot be read or if there's an issue accessing the directory.
+ */
+export declare function findChangeWithInboundId(projectPath: string, inboundId: string): InboundChangeData;
+/**
+ * Constructs a generic change object based on provided parameters.
+ *
+ * @param data - The base data associated with the change, including project data and timestamp.
+ * @param data.projectData - The project specific data.
+ * @param data.timestamp - The timestamp.
+ * @param {object} content - The content of the change to be applied.
+ * @param {ChangeType} changeType - The type of the change.
+ * @returns An object representing the change.
+ */
+export declare function getGenericChange(data: {
+    projectData: AdpProjectData;
+    timestamp: number;
+}, content: object, changeType: ChangeType): ManifestChangeProperties;
+export {};
+//# sourceMappingURL=change-utils.d.ts.map

package/dist/base/change-utils.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGenericChange = exports.findChangeWithInboundId = exports.getParsedPropertyValue = exports.parseStringToObject = exports.writeChangeToFile = exports.writeChangeToFolder = exports.writeAnnotationChange = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+/**
+ * Writes annotation changes to the specified project path using the provided `mem-fs-editor` instance.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {AnnotationsData} data - The data object containing information about the annotation change.
+ * @param {ManifestChangeProperties} change - The annotation data change that will be written.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ * @returns {void}
+ */
+function writeAnnotationChange(projectPath, data, change, fs) {
+    var _a;
+    try {
+        const { timestamp, annotation } = data;
+        const changeFileName = `id_${timestamp}_addAnnotationsToOData.change`;
+        const changesFolderPath = path_1.default.join(projectPath, "webapp" /* FolderTypes.WEBAPP */, "changes" /* FolderTypes.CHANGES */);
+        const changeFilePath = path_1.default.join(changesFolderPath, "manifest" /* FolderTypes.MANIFEST */, changeFileName);
+        const annotationsFolderPath = path_1.default.join(changesFolderPath, "annotations" /* FolderTypes.ANNOTATIONS */);
+        writeChangeToFile(changeFilePath, change, fs);
+        if (!annotation.filePath) {
+            fs.write(path_1.default.join(annotationsFolderPath, (_a = annotation.fileName) !== null && _a !== void 0 ? _a : ''), '');
+        }
+        else {
+            const { filePath, fileName } = annotation;
+            const selectedDir = path_1.default.dirname(filePath);
+            if (selectedDir !== annotationsFolderPath) {
+                fs.copy(filePath, path_1.default.join(annotationsFolderPath, fileName !== null && fileName !== void 0 ? fileName : ''));
+            }
+        }
+    }
+    catch (e) {
+        throw new Error(`Could not write annotation changes. Reason: ${e.message}`);
+    }
+}
+exports.writeAnnotationChange = writeAnnotationChange;
+/**
+ * Writes a given change object to a file within a specified folder in the project's 'changes' directory.
+ * If an additional subdirectory is specified, the change file is written there.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {ManifestChangeProperties} change - The change data to be written to the file.
+ * @param {string} fileName - The name of the file to write the change data to.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ * @param {string} [dir] - An optional subdirectory within the 'changes' directory where the file will be written.
+ * @returns {void}
+ */
+function writeChangeToFolder(projectPath, change, fileName, fs, dir = '') {
+    try {
+        let targetFolderPath = path_1.default.join(projectPath, "webapp" /* FolderTypes.WEBAPP */, "changes" /* FolderTypes.CHANGES */);
+        if (dir) {
+            targetFolderPath = path_1.default.join(targetFolderPath, dir);
+        }
+        const filePath = path_1.default.join(targetFolderPath, fileName);
+        writeChangeToFile(filePath, change, fs);
+    }
+    catch (e) {
+        throw new Error(`Could not write change to folder. Reason: ${e.message}`);
+    }
+}
+exports.writeChangeToFolder = writeChangeToFolder;
+/**
+ * Writes a given change object to a specific file path. The change data is stringified to JSON format before
+ * writing. This function is used to directly write changes to a file, without specifying a directory.
+ *
+ * @param {string} path - The root path of the project.
+ * @param {ManifestChangeProperties} change - The change data to be written to the file.
+ * @param {Editor} fs - The `mem-fs-editor` instance used for file operations.
+ */
+function writeChangeToFile(path, change, fs) {
+    try {
+        fs.writeJSON(path, change);
+    }
+    catch (e) {
+        throw new Error(`Could not write change to file: ${path}. Reason: ${e.message}`);
+    }
+}
+exports.writeChangeToFile = writeChangeToFile;
+/**
+ * Parses a string into an object.
+ *
+ * @param {string} str - The string to be parsed into an object. The string should be in the format of object properties without the surrounding braces.
+ * @returns {{ [key: string]: string }} An object constructed from the input string.
+ * @example
+ * // returns { name: "value" }
+ * parseStringToObject('"name":"value"');
+ */
+function parseStringToObject(str) {
+    return JSON.parse(`{${str}}`);
+}
+exports.parseStringToObject = parseStringToObject;
+/**
+ * Attempts to parse a property value as JSON.
+ *
+ * @param {string} propertyValue - The property value to be parsed.
+ * @returns {PropertyValueType} The parsed value if `propertyValue` is valid JSON; otherwise, returns the original `propertyValue`.
+ * @example
+ * // Returns the object { key: "value" }
+ * getParsedPropertyValue('{"key": "value"}');
+ *
+ * // Returns the string "nonJSONValue" because it cannot be parsed as JSON
+ * getParsedPropertyValue('nonJSONValue');
+ */
+function getParsedPropertyValue(propertyValue) {
+    try {
+        const value = JSON.parse(propertyValue);
+        return value;
+    }
+    catch (e) {
+        return propertyValue;
+    }
+}
+exports.getParsedPropertyValue = getParsedPropertyValue;
+/**
+ * Searches for a change file with a specific inbound ID within a project's change directory.
+ *
+ * @param {string} projectPath - The root path of the project.
+ * @param {string} inboundId - The inbound ID to search for within change files.
+ * @returns {InboundChangeData} An object containing the file path and the change object with the matching inbound ID.
+ * @throws {Error} Throws an error if the change file cannot be read or if there's an issue accessing the directory.
+ */
+function findChangeWithInboundId(projectPath, inboundId) {
+    var _a;
+    let changeObj;
+    let filePath = '';
+    const pathToInboundChangeFiles = path_1.default.join(projectPath, "webapp" /* FolderTypes.WEBAPP */, "changes" /* FolderTypes.CHANGES */, "manifest" /* FolderTypes.MANIFEST */);
+    if (!(0, fs_1.existsSync)(pathToInboundChangeFiles)) {
+        return {
+            filePath,
+            changeWithInboundId: changeObj
+        };
+    }
+    try {
+        const file = (0, fs_1.readdirSync)(pathToInboundChangeFiles, { withFileTypes: true }).find((dirent) => dirent.isFile() && dirent.name.includes('changeInbound'));
+        if (file) {
+            const pathToFile = path_1.default.join(pathToInboundChangeFiles, file.name);
+            const change = JSON.parse((0, fs_1.readFileSync)(pathToFile, 'utf-8'));
+            if (((_a = change.content) === null || _a === void 0 ? void 0 : _a.inboundId) === inboundId) {
+                changeObj = change;
+                filePath = pathToFile;
+            }
+        }
+        return {
+            filePath,
+            changeWithInboundId: changeObj
+        };
+    }
+    catch (e) {
+        throw new Error(`Could not find change with inbound id '${inboundId}'. Reason: ${e.message}`);
+    }
+}
+exports.findChangeWithInboundId = findChangeWithInboundId;
+/**
+ * Constructs a generic change object based on provided parameters.
+ *
+ * @param data - The base data associated with the change, including project data and timestamp.
+ * @param data.projectData - The project specific data.
+ * @param data.timestamp - The timestamp.
+ * @param {object} content - The content of the change to be applied.
+ * @param {ChangeType} changeType - The type of the change.
+ * @returns An object representing the change.
+ */
+function getGenericChange(data, content, changeType) {
+    const { projectData, timestamp } = data;
+    const fileName = `id_${timestamp}`;
+    return {
+        fileName,
+        namespace: path_1.default.posix.join(projectData.namespace, "changes" /* FolderTypes.CHANGES */),
+        layer: projectData.layer,
+        fileType: 'change',
+        creation: new Date(timestamp).toISOString(),
+        packageName: '$TMP',
+        reference: projectData.id,
+        support: { generator: '@sap-ux/adp-tooling' },
+        changeType,
+        content
+    };
+}
+exports.getGenericChange = getGenericChange;
+//# sourceMappingURL=change-utils.js.map

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export { AdpPreviewConfig, AdpWriterConfig } from './types';
+export * from './types';
 export * from './preview/adp-preview';
 export { generate } from './writer';
+export { generateChange } from './writer/editors';
 export { promptGeneratorInput, PromptDefaults } from './base/prompt';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -14,10 +14,13 @@ 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 });
-exports.promptGeneratorInput = exports.generate = void 0;
+exports.promptGeneratorInput = exports.generateChange = exports.generate = void 0;
+__exportStar(require("./types"), exports);
 __exportStar(require("./preview/adp-preview"), exports);
 var writer_1 = require("./writer");
 Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return writer_1.generate; } });
+var editors_1 = require("./writer/editors");
+Object.defineProperty(exports, "generateChange", { enumerable: true, get: function () { return editors_1.generateChange; } });
 var prompt_1 = require("./base/prompt");
 Object.defineProperty(exports, "promptGeneratorInput", { enumerable: true, get: function () { return prompt_1.promptGeneratorInput; } });
 //# sourceMappingURL=index.js.map

package/dist/preview/routes-handler.js

@@ -95,7 +95,7 @@ class RoutesHandler {
                     this.logger.debug('Bad request. Fragment name was not provided!');
                     return;
                 }
-                const fullPath = path.join(sourcePath, "changes" /* FolderNames.Changes */, "fragments" /* FolderNames.Fragments */);
+                const fullPath = path.join(sourcePath, "changes" /* FolderTypes.CHANGES */, "fragments" /* FolderTypes.FRAGMENTS */);
                 const filePath = path.join(fullPath, `${fragmentName}.fragment.xml`);
                 if (!fs.existsSync(fullPath)) {
                     fs.mkdirSync(fullPath, { recursive: true });
@@ -161,7 +161,7 @@ class RoutesHandler {
                 const project = this.util.getProject();
                 const sourcePath = project.getSourcePath();
                 const projectName = project.getName();
-                const getPath = (projectPath, fileName, folder = "coding" /* FolderNames.Coding */) => path.join(projectPath, "changes" /* FolderNames.Changes */, folder, fileName).split(path.sep).join(path.posix.sep);
+                const getPath = (projectPath, fileName, folder = "coding" /* FolderTypes.CODING */) => path.join(projectPath, "changes" /* FolderTypes.CHANGES */, folder, fileName).split(path.sep).join(path.posix.sep);
                 for (const file of codeExtFiles) {
                     const fileStr = yield file.getString();
                     const change = JSON.parse(fileStr);
@@ -211,7 +211,7 @@ class RoutesHandler {
                     this.logger.debug('Bad request. Controller extension name was not provided!');
                     return;
                 }
-                const fullPath = path.join(sourcePath, "changes" /* FolderNames.Changes */, "coding" /* FolderNames.Coding */);
+                const fullPath = path.join(sourcePath, "changes" /* FolderTypes.CHANGES */, "coding" /* FolderTypes.CODING */);
                 const filePath = path.join(fullPath, `${controllerExtName}.js`);
                 if (!fs.existsSync(fullPath)) {
                     fs.mkdirSync(fullPath, { recursive: true });

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { UI5FlexLayer } from '@sap-ux/project-access';
 import type { DestinationAbapTarget, UrlAbapTarget } from '@sap-ux/system-access';
 import type { Adp } from '@sap-ux/ui5-config';
+import type { Editor } from 'mem-fs-editor';
 export interface DescriptorVariant {
     layer: UI5FlexLayer;
     reference: string;
@@ -77,6 +78,20 @@ interface CommonChangeProperties {
     fileName: string;
     texts: Record<string, unknown>;
 }
+export interface ManifestChangeProperties {
+    fileName: string;
+    fileType: string;
+    namespace: string;
+    layer: string;
+    packageName: string;
+    reference: string;
+    support: {
+        generator: string;
+    };
+    changeType: string;
+    creation: string;
+    content: object;
+}
 export interface AddXMLChange extends CommonChangeProperties {
     changeType: 'addXML';
     creation: string;
@@ -102,10 +117,13 @@ export interface CodeExtChange extends CommonChangeProperties {
         controllerName: string;
     };
 }
-export declare const enum FolderNames {
-    Changes = "changes",
-    Fragments = "fragments",
-    Coding = "coding"
+export declare const enum FolderTypes {
+    CHANGES = "changes",
+    FRAGMENTS = "fragments",
+    CODING = "coding",
+    MANIFEST = "manifest",
+    ANNOTATIONS = "annotations",
+    WEBAPP = "webapp"
 }
 export declare const enum TemplateFileName {
     Fragment = "fragment.xml",
@@ -125,5 +143,177 @@ export declare const enum HttpStatusCodes {
     NOT_IMPLEMETED = 501,
     SERVICE_UNAVAILABLE = 503
 }
+/**
+ * Represents a constructor type that creates an instance of IWriter.
+ *
+ * @param fs - An instance of Editor used for file system operations.
+ * @param projectPath - The root path of the project.
+ * @returns An instance of IWriter for handling specific data writing operations.
+ */
+export type Writer = new (fs: Editor, projectPath: string) => IWriter<any>;
+/**
+ * Generic interface for handling data associated with specific writer operations.
+ * Allows for the typing of data passed to IWriter implementations based on the change type.
+ *
+ * @template T - The subtype of ChangeType that specifies the kind of change and associated data.
+ */
+export type IWriterData<T extends ChangeType> = IWriter<GeneratorData<T>>;
+/**
+ * Defines a generic interface for writer classes, specialized by the type of data they handle.
+ *
+ * @template T - The specific type of data the writer will handle, determined by the associated ChangeType.
+ */
+export interface IWriter<T> {
+    /**
+     * Writes the provided data to the project.
+     *
+     * @param data - The data needed for the writer function, specific to the type of change being made.
+     */
+    write(data: T): Promise<void>;
+}
+/**
+ * Enumerates the types of changes that can be made, each representing a specific kind of modification.
+ */
+export declare const enum ChangeType {
+    ADD_NEW_MODEL = "appdescr_ui5_addNewModel",
+    ADD_ANNOTATIONS_TO_ODATA = "appdescr_app_addAnnotationsToOData",
+    CHANGE_DATA_SOURCE = "appdescr_app_changeDataSource",
+    ADD_COMPONENT_USAGES = "appdescr_ui5_addComponentUsages",
+    ADD_LIBRARY_REFERENCE = "appdescr_ui5_addLibraries",
+    CHANGE_INBOUND = "appdescr_app_changeInbound"
+}
+/**
+ * Maps a ChangeType to the corresponding data structure needed for that type of change.
+ * This conditional type ensures type safety by linking each change type with its relevant data model.
+ *
+ * @template T - A subtype of ChangeType indicating the specific type of change.
+ */
+export type GeneratorData<T extends ChangeType> = T extends ChangeType.ADD_ANNOTATIONS_TO_ODATA ? AnnotationsData : T extends ChangeType.ADD_COMPONENT_USAGES ? ComponentUsagesData : T extends ChangeType.ADD_LIBRARY_REFERENCE ? ComponentUsagesData : T extends ChangeType.ADD_NEW_MODEL ? NewModelData : T extends ChangeType.CHANGE_DATA_SOURCE ? DataSourceData : T extends ChangeType.CHANGE_INBOUND ? InboundData : never;
+export interface AnnotationsData {
+    projectData: AdpProjectData;
+    timestamp: number;
+    /** Indicates whether the annotation is for internal use only. */
+    isInternalUsage: boolean;
+    annotation: {
+        /** Optional name of the annotation file. */
+        fileName?: string;
+        /** Data source associated with the annotation. */
+        dataSource: string;
+        /** Path to the annotation file. */
+        filePath: string;
+    };
+}
+export interface ComponentUsagesData {
+    projectData: AdpProjectData;
+    timestamp: number;
+    component: {
+        /** Indicates whether the component is loaded lazily. */
+        isLazy: string;
+        /** Unique ID for the component usage. */
+        usageId: string;
+        /** Name of the component. */
+        name: string;
+        /** Serialized data specific to the component. */
+        data: string;
+        /** Settings related to the component. */
+        settings: string;
+    };
+    library: {
+        /** Reference to the component's library. */
+        reference: string;
+        /** Optional flag indicating if the library reference is lazy. */
+        referenceIsLazy?: string;
+    };
+}
+export interface NewModelData {
+    projectData: AdpProjectData;
+    timestamp: number;
+    annotation: {
+        /** Name of the OData annotation data source. */
+        dataSourceName: string;
+        /** Optional URI of the OData annotation data source. */
+        dataSourceURI?: string;
+        /** Optional settings for the OData annotation. */
+        settings?: string;
+    };
+    service: {
+        /** Name of the OData service. */
+        name: string;
+        /** URI of the OData service. */
+        uri: string;
+        /** Name of the OData service model. */
+        modelName: string;
+        /** Version of OData used. */
+        version: string;
+        /** Settings for the OData service model. */
+        modelSettings: string;
+    };
+    /** Indicates whether annotation mode is added. */
+    addAnnotationMode: boolean;
+}
+export interface DataSourceData {
+    projectData: AdpProjectData;
+    timestamp: number;
+    service: {
+        /** Data source identifier. */
+        name: string;
+        /** URI of the data source. */
+        uri: string;
+        /** Optional maximum age for the data source cache. */
+        maxAge?: number;
+        /** URI for the OData annotation source. */
+        annotationUri: string;
+    };
+    /** Dictionary mapping data source keys to their values. */
+    dataSourcesDictionary: {
+        [key: string]: string;
+    };
+}
+export interface InboundData {
+    projectData: AdpProjectData;
+    timestamp: number;
+    /** Identifier for the inbound navigation data. */
+    inboundId: string;
+    flp: {
+        /** Title associated with the inbound navigation data. */
+        title: PropertyValueType;
+        /** Subtitle associated with the inbound navigation data. */
+        subTitle: PropertyValueType;
+        /** Icon associated with the inbound navigation data. */
+        icon: PropertyValueType;
+    };
+    /** Optional flag indicating if the project is in safe mode. */
+    isInSafeMode?: boolean;
+}
+export interface InboundContent {
+    inboundId: string;
+    entityPropertyChange: {
+        propertyPath: string;
+        operation: string;
+        propertyValue: unknown;
+    }[];
+}
+export type DataSourceItem = {
+    uri?: string;
+    type: string;
+    settings: {
+        [key: string]: unknown;
+    };
+};
+export type PropertyValueType = 'boolean' | 'number' | 'string' | 'binding' | 'object';
+export interface AdpProjectData {
+    path: string;
+    title: string;
+    namespace: string;
+    ui5Version: string;
+    name: string;
+    layer: string;
+    environment: string;
+    safeMode: boolean;
+    sourceSystem: string;
+    applicationIdx: string;
+    reference: string;
+    id: string;
+}
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/writer/changes/writer-factory.d.ts

@@ -0,0 +1,20 @@
+import type { Editor } from 'mem-fs-editor';
+import { ChangeType } from '../../types';
+import type { IWriterData } from '../../types';
+/**
+ * Handles the creation of a writer instance based on the generator type.
+ */
+export declare class WriterFactory {
+    private static writers;
+    /**
+     * Creates an instance of a writer based on the specified generator type.
+     *
+     * @param {T} type - The type of the change which will be handled by the writer.
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The path to the project for which the writer is created.
+     * @returns {IWriterData<T>} An instance of the writer associated with the specified generator type.
+     * @throws {Error} If the specified generator type is not supported.
+     */
+    static createWriter<T extends ChangeType>(type: T, fs: Editor, projectPath: string): IWriterData<T>;
+}
+//# sourceMappingURL=writer-factory.d.ts.map

package/dist/writer/changes/writer-factory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriterFactory = void 0;
+const writers_1 = require("./writers");
+/**
+ * Handles the creation of a writer instance based on the generator type.
+ */
+class WriterFactory {
+    /**
+     * Creates an instance of a writer based on the specified generator type.
+     *
+     * @param {T} type - The type of the change which will be handled by the writer.
+     * @param {Editor} fs - The filesystem editor instance.
+     * @param {string} projectPath - The path to the project for which the writer is created.
+     * @returns {IWriterData<T>} An instance of the writer associated with the specified generator type.
+     * @throws {Error} If the specified generator type is not supported.
+     */
+    static createWriter(type, fs, projectPath) {
+        const WriterClass = this.writers.get(type);
+        if (!WriterClass) {
+            throw new Error(`Unsupported generator type: ${type}`);
+        }
+        return new WriterClass(fs, projectPath);
+    }
+}
+exports.WriterFactory = WriterFactory;
+WriterFactory.writers = new Map([
+    ["appdescr_app_addAnnotationsToOData" /* ChangeType.ADD_ANNOTATIONS_TO_ODATA */, writers_1.AnnotationsWriter],
+    ["appdescr_ui5_addComponentUsages" /* ChangeType.ADD_COMPONENT_USAGES */, writers_1.ComponentUsagesWriter],
+    ["appdescr_ui5_addLibraries" /* ChangeType.ADD_LIBRARY_REFERENCE */, writers_1.ComponentUsagesWriter],
+    ["appdescr_ui5_addNewModel" /* ChangeType.ADD_NEW_MODEL */, writers_1.NewModelWriter],
+    ["appdescr_app_changeDataSource" /* ChangeType.CHANGE_DATA_SOURCE */, writers_1.DataSourceWriter],
+    ["appdescr_app_changeInbound" /* ChangeType.CHANGE_INBOUND */, writers_1.InboundWriter]
+]);
+//# sourceMappingURL=writer-factory.js.map

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

@@ -0,0 +1,36 @@
+import type { Editor } from 'mem-fs-editor';
+import type { IWriter, AnnotationsData } from '../../../types';
+/**
+ * Handles the creation and writing of annotations data changes for a project.
+ */
+export declare class AnnotationsWriter implements IWriter<AnnotationsData> {
+    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 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.
+     */
+    private constructContent;
+    /**
+     * 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.
+     */
+    private getAnnotationFileName;
+    /**
+     * 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: AnnotationsData): Promise<void>;
+}
+//# sourceMappingURL=annotations-writer.d.ts.map