@sap-ux/fe-fpm-writer 0.40.12 → 0.41.1

package/dist/building-block/index.d.ts

@@ -1,32 +1,6 @@
 import type { Editor } from 'mem-fs-editor';
-import { BuildingBlockType, type BuildingBlock, type BuildingBlockConfig, type EmbededFragment } from './types';
-import type { InternalCustomElement } from '../common/types';
+import { type BuildingBlock, type BuildingBlockConfig } from './types';
 import { type CodeSnippet } from '../prompts/types';
-/**
- * Type for embedded fragment data used in building block processing.
- */
-type EmbeddedFragmentData = InternalCustomElement & EmbededFragment;
-/**
- * Configuration for building block templates.
- */
-interface BuildingBlockTemplateConfig {
-    nodes: {
-        explicit: string;
-        default: string;
-    };
-    templateType: string;
-    templateFile: string;
-    namespace: {
-        uri: string;
-        prefix: string;
-    };
-    resultPropertyName: string;
-    processor: (buildingBlockData: BuildingBlock, fs: Editor, viewPath: string, config: BuildingBlockTemplateConfig, embededFragment?: EmbeddedFragmentData) => void;
-}
-/**
- * Configuration map for building block types.
- */
-export declare const BUILDING_BLOCK_CONFIG: Partial<Record<BuildingBlockType, BuildingBlockTemplateConfig>>;
 /**
  * Generates a building block into the provided xml view file.
  *
@@ -55,5 +29,4 @@ export declare function getManifestContent(fs: Editor, library?: string): Promis
 export declare function getSerializedFileContent<T extends BuildingBlock>(basePath: string, config: BuildingBlockConfig<T>, fs?: Editor): Promise<{
     [questionName: string]: CodeSnippet;
 }>;
-export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/building-block/index.js

@@ -36,7 +36,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILDING_BLOCK_CONFIG = void 0;
 exports.generateBuildingBlock = generateBuildingBlock;
 exports.getManifestContent = getManifestContent;
 exports.getSerializedFileContent = getSerializedFileContent;
@@ -53,38 +52,16 @@ const types_1 = require("./types");
 const validate_1 = require("../common/validate");
 const templates_1 = require("../templates");
 const types_2 = require("../prompts/types");
-const event_handler_1 = require("../common/event-handler");
 const file_1 = require("../common/file");
 const utils_1 = require("../common/utils");
-const defaults_1 = require("../common/defaults");
 const xml_1 = require("./prompts/utils/xml");
 const i18n_1 = require("../i18n");
+const processor_1 = require("./processor");
 const PLACEHOLDERS = {
     'id': 'REPLACE_WITH_BUILDING_BLOCK_ID',
     'entitySet': 'REPLACE_WITH_ENTITY',
     'qualifier': 'REPLACE_WITH_A_QUALIFIER'
 };
-/**
- * Configuration map for building block types.
- */
-exports.BUILDING_BLOCK_CONFIG = {
-    [types_1.BuildingBlockType.CustomColumn]: {
-        nodes: { explicit: 'columns', default: 'Column' },
-        templateType: 'common',
-        templateFile: 'common/Fragment.xml',
-        namespace: { uri: 'sap.fe.macros.table', prefix: 'macrosTable' },
-        resultPropertyName: 'hasTableColumns',
-        processor: processCustomColumn
-    },
-    [types_1.BuildingBlockType.CustomFilterField]: {
-        nodes: { explicit: 'filterFields', default: 'FilterField' },
-        templateType: 'filter',
-        templateFile: 'filter/fragment.xml',
-        namespace: { uri: 'sap.fe.macros.filterBar', prefix: 'macros' },
-        resultPropertyName: 'hasFilterFields',
-        processor: processCustomFilterField
-    }
-};
 /**
  * Generates a building block into the provided xml view file.
  *
@@ -106,13 +83,14 @@ async function generateBuildingBlock(basePath, config, fs) {
     const { path: manifestPath, content: manifest } = await (0, utils_1.getManifest)(basePath, fs);
     // Read the view xml and template files and update contents of the view xml file
     const xmlDocument = getUI5XmlDocument(basePath, viewOrFragmentPath, fs);
-    const { updatedAggregationPath, processedBuildingBlockData, hasAggregation, aggregationNamespace } = processBuildingBlock(buildingBlockData, xmlDocument, manifestPath, manifest, aggregationPath, fs);
+    const { updatedAggregationPath, processedBuildingBlockData, hasAggregation, aggregationNamespace } = (0, processor_1.processBuildingBlock)(buildingBlockData, xmlDocument, manifestPath, manifest, aggregationPath, fs);
     const templateConfig = {
         hasAggregation,
         aggregationNamespace
     };
     const templateDocument = getTemplateDocument(processedBuildingBlockData, xmlDocument, fs, manifest, templateConfig);
-    if (buildingBlockData.buildingBlockType === types_1.BuildingBlockType.RichTextEditor) {
+    if (buildingBlockData.buildingBlockType === types_1.BuildingBlockType.RichTextEditor ||
+        buildingBlockData.buildingBlockType === types_1.BuildingBlockType.RichTextEditorButtonGroups) {
         const minUI5Version = manifest ? (0, semver_1.coerce)((0, project_access_1.getMinimumUI5Version)(manifest)) : undefined;
         if (minUI5Version && (0, semver_1.lt)(minUI5Version, '1.117.0')) {
             const t = (0, i18n_1.translate)(i18n_1.i18nNamespaces.buildingBlock, 'richTextEditorBuildingBlock.');
@@ -135,177 +113,6 @@ async function generateBuildingBlock(basePath, config, fs) {
     }
     return fs;
 }
-/**
- * Updates aggregation path based on XML document structure.
- *
- * @param {Document} xmlDocument - The XML document to analyze
- * @param {string} aggregationPath - The current aggregation path
- * @param {CustomColumn | CustomFilterField} buildingBlockData - The building block data with embedded fragment
- * @param {AggregationConfig} config - Configuration specifying aggregation and element names
- * @returns {object} Object containing the updated aggregation path
- */
-function updateAggregationPath(xmlDocument, aggregationPath, buildingBlockData, config) {
-    if (!buildingBlockData.embededFragment) {
-        return { updatedAggregationPath: aggregationPath, hasElement: false };
-    }
-    const xpathSelect = xpath.useNamespaces(xmlDocument.firstChild._nsMap);
-    // First, get the target element from the aggregationPath
-    const targetElement = xpathSelect(aggregationPath, xmlDocument);
-    if (!targetElement || !Array.isArray(targetElement) || targetElement.length === 0) {
-        return { updatedAggregationPath: aggregationPath, hasElement: false };
-    }
-    const targetNode = targetElement[0];
-    // Check if the explicit aggregation exists within the specific target element
-    const hasAggregation = xpathSelect(`./*[local-name()='${config.aggregationName}']`, targetNode);
-    if (hasAggregation && Array.isArray(hasAggregation) && hasAggregation.length > 0) {
-        return {
-            updatedAggregationPath: aggregationPath + `/${(0, xml_1.getOrAddNamespace)(xmlDocument)}:${config.aggregationName}`,
-            hasElement: true
-        };
-    }
-    else {
-        // Check if the default aggregation element exists within the specific target element
-        const useDefaultAggregation = xpathSelect(`./*[local-name()='${config.elementName}']`, targetNode);
-        if (useDefaultAggregation && Array.isArray(useDefaultAggregation) && useDefaultAggregation.length > 0) {
-            return { updatedAggregationPath: aggregationPath, hasElement: true };
-        }
-    }
-    return { updatedAggregationPath: aggregationPath, hasElement: false };
-}
-/**
- * Processes building block configuration.
- *
- * @param {BuildingBlock} buildingBlockData - The building block data
- * @param {Document} xmlDocument - The XML document
- * @param {string} manifestPath - The manifest file path
- * @param {Manifest} manifest - The manifest object
- * @param {string} aggregationPath - The aggregation path
- * @param {Editor} fs - The memfs editor instance
- * @returns {object} Object containing updated aggregation path and processed building block data
- */
-function processBuildingBlock(buildingBlockData, xmlDocument, manifestPath, manifest, aggregationPath, fs) {
-    let updatedAggregationPath = aggregationPath;
-    let hasAggregation = false;
-    let aggregationNamespace = 'macrosTable';
-    let embededFragment;
-    let viewPath;
-    // Get configuration for the building block type
-    const config = exports.BUILDING_BLOCK_CONFIG[buildingBlockData.buildingBlockType];
-    if (!config) {
-        // Return defaults if no configuration is found
-        return {
-            updatedAggregationPath,
-            processedBuildingBlockData: buildingBlockData,
-            hasAggregation,
-            aggregationNamespace
-        };
-    }
-    // Process embedded fragment for types that support it
-    if ((isCustomColumn(buildingBlockData) || isCustomFilterField(buildingBlockData)) &&
-        buildingBlockData.embededFragment) {
-        embededFragment = (0, defaults_1.setCommonDefaults)(buildingBlockData.embededFragment, manifestPath, manifest);
-        viewPath = (0, node_path_1.join)(embededFragment.path, `${embededFragment.fragmentFile ?? embededFragment.name}.fragment.xml`);
-        // Use the processor function from the configuration
-        config.processor(buildingBlockData, fs, viewPath, config, embededFragment);
-        const result = updateAggregationPath(xmlDocument, aggregationPath, buildingBlockData, {
-            aggregationName: config.nodes.explicit,
-            elementName: config.nodes.default,
-            resultPropertyName: config.resultPropertyName
-        });
-        updatedAggregationPath = result.updatedAggregationPath;
-        hasAggregation = result.hasElement;
-        aggregationNamespace = (0, xml_1.getOrAddNamespace)(xmlDocument, config.namespace.uri, config.namespace.prefix);
-    }
-    return {
-        updatedAggregationPath,
-        processedBuildingBlockData: buildingBlockData,
-        hasAggregation,
-        aggregationNamespace
-    };
-}
-/**
- * Processes custom column building block.
- *
- * @param {BuildingBlock} buildingBlockData - The building block data
- * @param {Editor} fs - The memfs editor instance
- * @param {string} viewPath - The view path
- * @param {BuildingBlockTemplateConfig} config - The building block configuration
- */
-function processCustomColumn(buildingBlockData, fs, viewPath, config) {
-    if (!isCustomColumn(buildingBlockData)) {
-        throw new Error('Expected CustomColumn building block data');
-    }
-    const columnConfig = buildingBlockData.embededFragment;
-    let processedEventHandler;
-    // Apply event handler
-    if (columnConfig.eventHandler) {
-        processedEventHandler = (0, event_handler_1.applyEventHandlerConfiguration)(fs, columnConfig, columnConfig.eventHandler, {
-            controllerSuffix: false,
-            typescript: columnConfig.typescript
-        });
-        columnConfig.eventHandler = processedEventHandler;
-    }
-    columnConfig.content = (0, defaults_1.getDefaultFragmentContent)('Sample Text', processedEventHandler);
-    if (!fs.exists(viewPath)) {
-        (0, file_1.copyTpl)(fs, (0, templates_1.getTemplatePath)(config.templateFile), viewPath, columnConfig);
-    }
-}
-/**
- * Processes custom filter field building block.
- *
- * @param {BuildingBlock} buildingBlockData - The building block data
- * @param {Editor} fs - The memfs editor instance
- * @param {string} viewPath - The view path
- * @param {BuildingBlockTemplateConfig} config - The building block configuration
- * @param {EmbeddedFragmentData} embededFragment - The embedded fragment data
- */
-function processCustomFilterField(buildingBlockData, fs, viewPath, config, embededFragment) {
-    if (!isCustomFilterField(buildingBlockData)) {
-        throw new Error('Expected CustomFilterField building block data');
-    }
-    if (!embededFragment) {
-        throw new Error('EmbeddedFragment is required for CustomFilterField');
-    }
-    const filterConfig = {
-        label: buildingBlockData.label,
-        property: buildingBlockData.property,
-        required: buildingBlockData.required ?? false,
-        position: buildingBlockData.position,
-        eventHandler: buildingBlockData.embededFragment?.eventHandler,
-        ns: embededFragment.ns,
-        name: embededFragment.name,
-        path: embededFragment.path
-    };
-    // Apply event handler
-    if (filterConfig.eventHandler) {
-        filterConfig.eventHandler = (0, event_handler_1.applyEventHandlerConfiguration)(fs, filterConfig, filterConfig.eventHandler, {
-            controllerSuffix: false,
-            typescript: buildingBlockData.embededFragment?.typescript,
-            templatePath: 'filter/Controller'
-        });
-    }
-    if (!fs.exists(viewPath)) {
-        (0, file_1.copyTpl)(fs, (0, templates_1.getTemplatePath)(config.templateFile), viewPath, filterConfig);
-    }
-}
-/**
- * Type guard to check if the building block data is a custom column.
- *
- * @param {BuildingBlock} data - The building block data to check
- * @returns {boolean} True if the data is a custom column
- */
-function isCustomColumn(data) {
-    return data.buildingBlockType === types_1.BuildingBlockType.CustomColumn;
-}
-/**
- * Type guard to check if the building block data is a custom filter field.
- *
- * @param {BuildingBlock} data - The building block data to check
- * @returns {boolean} True if the data is a custom filter field
- */
-function isCustomFilterField(data) {
-    return data.buildingBlockType === types_1.BuildingBlockType.CustomFilterField;
-}
 /**
  * Returns the UI5 xml file document (view/fragment).
  *

package/dist/building-block/processor.d.ts

@@ -0,0 +1,67 @@
+import type { Editor } from 'mem-fs-editor';
+import { BuildingBlockType, type BuildingBlock, type EmbededFragment } from './types';
+import type { Manifest, InternalCustomElement } from '../common/types';
+/**
+ * Type for embedded fragment data used in building block processing.
+ */
+type EmbeddedFragmentData = InternalCustomElement & EmbededFragment;
+/**
+ * Namespace for XML elements.
+ */
+interface NamespaceConfig {
+    uri: string;
+    prefix: string;
+}
+/**
+ * Context for processing building blocks.
+ */
+interface ProcessingContext {
+    fs: Editor;
+    xmlDocument?: Document;
+    viewPath?: string;
+    embeddedFragment?: EmbeddedFragmentData;
+    updatedAggregationPath?: string;
+    hasAggregation?: boolean;
+}
+/**
+ * Configuration for building block templates.
+ */
+interface BuildingBlockTemplateConfig {
+    aggregationConfig: {
+        aggregationName: string;
+        elementName: string;
+    };
+    templateFile?: string;
+    namespace: NamespaceConfig;
+    processor: (buildingBlockData: BuildingBlock, context: ProcessingContext) => void;
+}
+/**
+ * Button group configurations used for validation and providing available button groups.
+ */
+export declare const BUTTON_GROUP_CONFIGS: {
+    name: string;
+    buttons: string;
+}[];
+/**
+ * Configuration map for building block types.
+ */
+export declare const BUILDING_BLOCK_CONFIG: Partial<Record<BuildingBlockType, BuildingBlockTemplateConfig>>;
+/**
+ * Processes building block configuration.
+ *
+ * @param {BuildingBlock} buildingBlockData - The building block data
+ * @param {Document} xmlDocument - The XML document
+ * @param {string} manifestPath - The manifest file path
+ * @param {Manifest} manifest - The manifest object
+ * @param {string} aggregationPath - The aggregation path
+ * @param {Editor} fs - The memfs editor instance
+ * @returns {object} Object containing updated aggregation path and processed building block data
+ */
+export declare function processBuildingBlock<T extends BuildingBlock>(buildingBlockData: T, xmlDocument: Document, manifestPath: string, manifest: Manifest, aggregationPath: string, fs: Editor): {
+    updatedAggregationPath: string;
+    processedBuildingBlockData: T;
+    hasAggregation: boolean;
+    aggregationNamespace: string;
+};
+export {};
+//# sourceMappingURL=processor.d.ts.map