@sap-ux/fe-fpm-writer 1.0.8 → 1.1.1

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

@@ -1,5 +1,5 @@
 import type { Editor } from 'mem-fs-editor';
-import { type BuildingBlock, type BuildingBlockConfig } from './types.js';
+import { type BuildingBlock, type BuildingBlockConfig, type GenerateBuildingBlockAggregationConfig } from './types.js';
 import { type CodeSnippet } from '../prompts/types.js';
 /**
  * Generates a building block into the provided xml view file.
@@ -10,6 +10,15 @@ import { type CodeSnippet } from '../prompts/types.js';
  * @returns {Editor} the updated memfs editor instance
  */
 export declare function generateBuildingBlock<T extends BuildingBlock>(basePath: string, config: BuildingBlockConfig<T>, fs?: Editor): Promise<Editor>;
+/**
+ * Appends a single Page building block aggregation template to an existing `<macros:Page>` element in a view XML file.
+ *
+ * @param {string} basePath - the base path of the application
+ * @param {GenerateBuildingBlockAggregationConfig} config - the aggregation configuration containing aggregationName and mContent
+ * @param {Editor} [fs] - the memfs editor instance
+ * @returns {Editor} the updated memfs editor instance
+ */
+export declare function generateBuildingBlockAggregation(basePath: string, config: GenerateBuildingBlockAggregationConfig, fs?: Editor): Promise<Editor>;
 /**
  * Method returns the manifest content for the required dependency library.
  *

package/dist/building-block/index.js

@@ -6,12 +6,12 @@ import { join, parse, relative } from 'node:path';
 import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
 import format from 'xml-formatter';
 import * as xpath from 'xpath';
-import { getMinimumUI5Version } from '@sap-ux/project-access';
-import { BuildingBlockType, bindingContextAbsolute } from './types.js';
+import { getMinimumUI5Version, getAppProgrammingLanguage } from '@sap-ux/project-access';
+import { BuildingBlockType, PAGE_AGGREGATIONS, PAGE_TEMPLATE_TYPE_FULL, bindingContextAbsolute } from './types.js';
 import { getErrorMessage, validateBasePath, validateDependenciesLibs } from '../common/validate.js';
 import { getTemplatePath } from '../templates.js';
 import { CodeSnippetLanguage } from '../prompts/types.js';
-import { CONFIG, createIdGenerator, detectTabSpacing, extendJSON, getRelativeTemplateComponentPath } from '../common/file.js';
+import { CONFIG, copyTpl, createIdGenerator, detectTabSpacing, extendJSON, getRelativeTemplateComponentPath } from '../common/file.js';
 import { getManifest, getManifestPath } from '../common/utils.js';
 import { getOrAddNamespace } from './prompts/utils/xml.js';
 import { i18nNamespaces, translate } from '../i18n.js';
@@ -21,6 +21,16 @@ const PLACEHOLDERS = {
     'entitySet': 'REPLACE_WITH_ENTITY',
     'qualifier': 'REPLACE_WITH_A_QUALIFIER'
 };
+const PAGE_TEMPLATE_COMMENT = 'This is a sample template, event handlers should be added for implementation';
+/**
+ * Returns true if the building block data represents a Page building block with the full template type.
+ *
+ * @param data - the building block data
+ * @returns true if full Page template
+ */
+function isFullPageTemplate(data) {
+    return data.buildingBlockType === BuildingBlockType.Page && data.templateType === PAGE_TEMPLATE_TYPE_FULL;
+}
 /**
  * Generates a building block into the provided xml view file.
  *
@@ -47,6 +57,11 @@ export async function generateBuildingBlock(basePath, config, fs) {
         aggregationNamespace
     };
     const templateDocument = getTemplateDocument({ ...processedBuildingBlockData, generateId: fnGenerateId }, xmlDocument, fs, manifest, templateConfig);
+    const fullPageTemplate = isFullPageTemplate(buildingBlockData);
+    if (fullPageTemplate) {
+        const pageData = buildingBlockData;
+        appendPageAggregations(fs, xmlDocument, templateDocument, fnGenerateId, pageData);
+    }
     if (buildingBlockData.buildingBlockType === BuildingBlockType.RichTextEditor ||
         buildingBlockData.buildingBlockType === BuildingBlockType.RichTextEditorButtonGroups) {
         const minUI5Version = manifest ? coerce(getMinimumUI5Version(manifest)) : undefined;
@@ -57,6 +72,9 @@ export async function generateBuildingBlock(basePath, config, fs) {
         getOrAddNamespace(xmlDocument, 'sap.fe.macros.richtexteditor', 'richtexteditor');
     }
     fs = updateViewFile(basePath, viewOrFragmentPath, updatedAggregationPath, xmlDocument, templateDocument, fs, config.replace);
+    if (fullPageTemplate) {
+        await applyPageControllerTemplate(fs, basePath, viewOrFragmentPath);
+    }
     if (allowAutoAddDependencyLib && manifest && !validateDependenciesLibs(manifest, ['sap.fe.macros'])) {
         // "sap.fe.macros" is missing - enhance manifest.json for missing "sap.fe.macros"
         const manifestPath = await getManifestPath(basePath, fs);
@@ -71,6 +89,242 @@ export async function generateBuildingBlock(basePath, config, fs) {
     }
     return fs;
 }
+/**
+ * Resolves the sap.fe.macros namespace prefix from the view document.
+ * If sap.fe.macros is the default namespace (no prefix), declares xmlns:macros on the document element
+ * so that generated prefixed elements like <macros:items> remain valid.
+ *
+ * @param xmlDocument - the view XML document
+ * @returns the resolved namespace prefix string (e.g. 'macros')
+ */
+function resolveMacrosPrefix(xmlDocument) {
+    const prefix = getOrAddNamespace(xmlDocument, 'sap.fe.macros', 'macros');
+    if (prefix === '') {
+        xmlDocument.documentElement.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:macros', 'sap.fe.macros');
+        return 'macros';
+    }
+    return prefix;
+}
+/**
+ * Renders a Page aggregation EJS template and parses it as an XML fragment document.
+ * Inherits all xmlns:* declarations from the view root so inner content can use any view-declared prefix.
+ *
+ * @param fs - the memfs editor instance
+ * @param aggName - the aggregation name (e.g. 'footer', 'items')
+ * @param aggContext - the EJS template context
+ * @param aggContext.macrosPrefix - the namespace prefix string (e.g. 'macros:')
+ * @param aggContext.mContent - optional inner XML content for the aggregation
+ * @param aggContext.aggId - the generated unique ID for the aggregation element
+ * @param fragMacrosNS - the namespace prefix resolved for sap.fe.macros
+ * @param xmlDocument - the view XML document (used to inherit namespace declarations)
+ * @returns parsed XML document whose documentElement contains the aggregation child nodes
+ */
+function buildPageAggregationFragment(fs, aggName, aggContext, fragMacrosNS, xmlDocument) {
+    const aggPath = getTemplatePath(`/building-block/page/${aggName}.xml`);
+    const aggContent = render(fs.read(aggPath), aggContext, {}); // NOSONAR - template is a controlled file on disk, not user input
+    const extraNamespaces = Array.from(xmlDocument.documentElement.attributes)
+        .filter((a) => a.name.startsWith('xmlns:') && a.name !== `xmlns:${fragMacrosNS}` && a.name !== 'xmlns:m')
+        .map((a) => `${a.name}="${a.value}"`)
+        .join(' ');
+    const wrapped = `<root xmlns:${fragMacrosNS}="sap.fe.macros" xmlns="sap.m" xmlns:m="sap.m" ${extraNamespaces}>${aggContent}</root>`;
+    const errorHandler = (level, message) => {
+        throw new Error(`Unable to parse page aggregation fragment '${aggName}'. Details: [${level}] - ${message}`);
+    };
+    return new DOMParser({ errorHandler }).parseFromString(wrapped, 'text/xml');
+}
+/**
+ * Appends the 7 Page building block aggregation fragments as child elements of the templateDocument root.
+ *
+ * @param {Editor} fs - the memfs editor instance
+ * @param {Document} xmlDocument - the view XML document (used to resolve namespace prefixes)
+ * @param {Document} templateDocument - the template document whose root element receives the children
+ * @param {IdGeneratorFunction} generateId - function to generate unique IDs
+ * @param {Page} pageData - the Page building block data containing optional aggregation mContent
+ */
+function appendPageAggregations(fs, xmlDocument, templateDocument, generateId, pageData) {
+    const fragMacrosNS = resolveMacrosPrefix(xmlDocument);
+    const macrosPrefix = `${fragMacrosNS}:`;
+    const pageElement = templateDocument.documentElement;
+    pageElement.appendChild(templateDocument.createComment(PAGE_TEMPLATE_COMMENT));
+    for (const aggName of PAGE_AGGREGATIONS) {
+        const mContent = pageData.aggregations?.[aggName] ?? '';
+        const aggId = generateId(aggName);
+        const aggContext = { macrosPrefix, mContent, aggId };
+        const aggDoc = buildPageAggregationFragment(fs, aggName, aggContext, fragMacrosNS, xmlDocument);
+        for (const node of Array.from(aggDoc.documentElement.childNodes)) {
+            if (node.nodeType === 1 /* Element */) {
+                node.setAttribute('id', aggId);
+                pageElement.appendChild(templateDocument.importNode(node, true));
+            }
+        }
+    }
+}
+/**
+ * Returns the local name of an Element if it belongs to the sap.fe.macros namespace, otherwise an empty string.
+ * This ensures only Page aggregation elements are sorted by position; non-macros elements fall back to the items slot.
+ *
+ * @param el - the DOM Element
+ * @returns the local name string, or '' if not a sap.fe.macros element
+ */
+function getElementLocalName(el) {
+    if (el.namespaceURI !== 'sap.fe.macros') {
+        return '';
+    }
+    return typeof el.localName === 'string' ? el.localName : '';
+}
+/**
+ * Builds a comparator for sorting XmlAggregationGroups by their position in aggNames.
+ * Unknown elements fall back to the position of 'items'. Ties are broken by original index.
+ *
+ * @param aggNames - ordered list of aggregation names
+ * @returns comparator function for Array.prototype.sort
+ */
+function buildAggregationComparator(aggNames) {
+    const itemsIdx = aggNames.indexOf('items');
+    const fallbackIdx = itemsIdx === -1 ? aggNames.length : itemsIdx;
+    return (a, b) => {
+        const aIdx = aggNames.indexOf(getElementLocalName(a.element));
+        const bIdx = aggNames.indexOf(getElementLocalName(b.element));
+        const aOrder = aIdx === -1 ? fallbackIdx : aIdx;
+        const bOrder = bIdx === -1 ? fallbackIdx : bIdx;
+        return aOrder === bOrder ? a.originalIndex - b.originalIndex : aOrder - bOrder;
+    };
+}
+/**
+ * Reorders the child elements of a macros:Page node to match the canonical PAGE_AGGREGATIONS order.
+ * Preserves relative order of siblings with the same local name. Pure whitespace text nodes are dropped
+ * because the xml-formatter call that follows will regenerate proper indentation.
+ *
+ * @param pageElement - the macros:Page DOM node whose children should be sorted
+ */
+function sortPageAggregationChildren(pageElement) {
+    const allChildren = Array.from(pageElement.childNodes);
+    const aggNames = PAGE_AGGREGATIONS;
+    // Build pairs of [preceding comments, element] to preserve user comments.
+    // Comments that appear before the first element are treated as leading and will remain before all aggregation elements.
+    const groups = [];
+    const leadingComments = [];
+    let pendingComments = [];
+    let firstElementSeen = false;
+    for (const node of allChildren) {
+        if (node.nodeType === 8 /* Comment */) {
+            // Comments before the first element are leading; after, they are pending
+            (firstElementSeen ? pendingComments : leadingComments).push(node);
+        }
+        else if (node.nodeType === 1 /* Element */) {
+            firstElementSeen = true;
+            groups.push({ comments: pendingComments, element: node, originalIndex: groups.length });
+            pendingComments = [];
+        }
+        else if (node.nodeType === 3 /* Text */ && node.data?.trim()) {
+            // Preserve non-whitespace text nodes with their surrounding group
+            pendingComments.push(node);
+        }
+        // Pure whitespace text nodes are intentionally dropped (xml-formatter regenerates indentation)
+    }
+    groups.sort(buildAggregationComparator(aggNames));
+    while (pageElement.firstChild) {
+        pageElement.removeChild(pageElement.firstChild); // NOSONAR - xmldom nodes do not implement Node.remove()
+    }
+    // Re-insert leading comments first (always before any element)
+    for (const comment of leadingComments) {
+        pageElement.appendChild(comment);
+    }
+    for (const { comments, element } of groups) {
+        for (const comment of comments) {
+            pageElement.appendChild(comment);
+        }
+        pageElement.appendChild(element);
+    }
+    // Trailing orphan comments (after the last element)
+    for (const comment of pendingComments) {
+        pageElement.appendChild(comment);
+    }
+}
+/**
+ * Appends a single Page building block aggregation template to an existing `<macros:Page>` element in a view XML file.
+ *
+ * @param {string} basePath - the base path of the application
+ * @param {GenerateBuildingBlockAggregationConfig} config - the aggregation configuration containing aggregationName and mContent
+ * @param {Editor} [fs] - the memfs editor instance
+ * @returns {Editor} the updated memfs editor instance
+ */
+export async function generateBuildingBlockAggregation(basePath, config, fs) {
+    const { viewPath, buildingBlockType, aggregationName: aggName, mContent = '' } = config;
+    fs ??= create(createStorage());
+    if (buildingBlockType !== BuildingBlockType.Page) {
+        throw new Error(`generateBuildingBlockAggregation: unsupported building block type '${buildingBlockType}'. Only 'Page' is currently supported.`);
+    }
+    const xmlDocument = getUI5XmlDocument(basePath, viewPath, fs);
+    const generateId = await createIdGenerator({ basePath, fsEditor: fs });
+    const aggId = generateId(aggName);
+    const fragMacrosNS = resolveMacrosPrefix(xmlDocument);
+    const macrosPrefix = `${fragMacrosNS}:`;
+    const aggContext = { macrosPrefix, mContent, aggId };
+    const aggDoc = buildPageAggregationFragment(fs, aggName, aggContext, fragMacrosNS, xmlDocument);
+    const nsMap = xmlDocument.documentElement?._nsMap ?? {};
+    // Prefix-agnostic XPath — works regardless of the alias used in the view for sap.fe.macros.
+    const xpathSelect = xpath.useNamespaces(nsMap);
+    const pageNodes = xpathSelect(`//*[local-name()='Page' and namespace-uri()='sap.fe.macros']`, xmlDocument);
+    if (!pageNodes || !Array.isArray(pageNodes) || pageNodes.length === 0) {
+        throw new Error(`Page element (sap.fe.macros) not found in view ${viewPath}.`);
+    }
+    const pageElement = pageNodes[0];
+    if (aggName === 'footer' && pageElement.nodeType === 1 /* Element */) {
+        pageElement.setAttribute('showFooter', 'true');
+    }
+    const childNodes = Array.from(pageElement.childNodes);
+    const hasExistingAggregation = childNodes.some((node) => node.nodeType === 1 /* Element */ &&
+        node.localName === aggName &&
+        node.namespaceURI === 'sap.fe.macros');
+    if (hasExistingAggregation) {
+        sortPageAggregationChildren(pageElement);
+        const existingXmlContent = new XMLSerializer().serializeToString(xmlDocument);
+        fs.write(join(basePath, viewPath), format(existingXmlContent));
+        return fs;
+    }
+    const hasExistingElementChildren = childNodes.some((n) => n.nodeType === 1 /* Element */);
+    const hasTemplateComment = childNodes.some((n) => n.nodeType === 8 /* Comment */ && n.data?.includes(PAGE_TEMPLATE_COMMENT));
+    if (!hasExistingElementChildren && !hasTemplateComment) {
+        pageElement.appendChild(xmlDocument.createComment(PAGE_TEMPLATE_COMMENT));
+    }
+    for (const node of Array.from(aggDoc.documentElement.childNodes)) {
+        if (node.nodeType === 1 /* Element */) {
+            node.setAttribute('id', aggId);
+            pageElement.appendChild(xmlDocument.importNode(node, true));
+        }
+    }
+    sortPageAggregationChildren(pageElement);
+    const newXmlContent = new XMLSerializer().serializeToString(xmlDocument);
+    fs.write(join(basePath, viewPath), format(newXmlContent));
+    return fs;
+}
+/**
+ * Copies the Page controller template (JS or TS) into the view directory if no controller file exists yet.
+ * Uses getAppProgrammingLanguage to decide whether to generate a JS or TS controller stub.
+ *
+ * @param {Editor} fs - the memfs editor instance
+ * @param {string} basePath - the base path of the application
+ * @param {string} viewOrFragmentPath - the relative path of the view/fragment file
+ */
+async function applyPageControllerTemplate(fs, basePath, viewOrFragmentPath) {
+    if (!viewOrFragmentPath.endsWith('.view.xml')) {
+        return;
+    }
+    const { dir: viewDir, name: viewName } = parse(viewOrFragmentPath);
+    const viewBaseName = viewName.replace(/\.view$/, '');
+    const tsControllerPath = join(basePath, viewDir, `${viewBaseName}.controller.ts`);
+    const jsControllerPath = join(basePath, viewDir, `${viewBaseName}.controller.js`);
+    // Skip if a controller already exists in either language to avoid duplicate stubs
+    if (fs.exists(tsControllerPath) || fs.exists(jsControllerPath)) {
+        return;
+    }
+    const detectedLanguage = await getAppProgrammingLanguage(basePath, fs);
+    const isTypeScript = detectedLanguage === 'TypeScript';
+    const controllerExt = isTypeScript ? 'ts' : 'js';
+    const controllerPath = isTypeScript ? tsControllerPath : jsControllerPath;
+    copyTpl(fs, getTemplatePath(`/building-block/page/Controller.${controllerExt}`), controllerPath);
+}
 /**
  * Returns the UI5 xml file document (view/fragment).
  *
@@ -259,7 +513,12 @@ function getTemplateDocument(buildingBlockData, viewDocument, fs, manifest, temp
  * @returns {Editor} the updated memfs editor instance
  */
 function updateViewFile(basePath, viewPath, aggregationPath, viewDocument, templateDocument, fs, replace = false) {
-    const xpathSelect = xpath.useNamespaces(viewDocument.firstChild._nsMap);
+    const firstChild = viewDocument.firstChild;
+    if (!firstChild) {
+        throw new Error(`Unable to read namespace map from view ${viewPath}.`);
+    }
+    const nsMap = firstChild?._nsMap ?? {};
+    const xpathSelect = xpath.useNamespaces(nsMap);
     // Find target aggregated element and append template as child
     const targetNodes = xpathSelect(aggregationPath, viewDocument);
     if (targetNodes && Array.isArray(targetNodes) && targetNodes.length > 0) {
@@ -316,11 +575,32 @@ export async function getSerializedFileContent(basePath, config, fs) {
     // Read the view xml and template files and get content of the view xml file
     const xmlDocument = viewOrFragmentPath ? getUI5XmlDocument(basePath, viewOrFragmentPath, fs) : undefined;
     const { content: manifest, path: manifestPath } = await getManifest(basePath, fs, false);
-    const content = getTemplateContent(buildingBlockData, xmlDocument, manifest, fs, true);
+    const fnGenerateId = buildingBlockData.generateId ?? (await createIdGenerator({ basePath, fsEditor: fs }));
+    const content = getTemplateContent({ ...buildingBlockData, generateId: fnGenerateId }, xmlDocument, manifest, fs, true);
+    // For the full Page template, augment the snippet with all 7 aggregations
+    let viewOrFragmentContent = content;
+    const pageData = buildingBlockData;
+    const isFullPage = isFullPageTemplate(buildingBlockData);
+    if (isFullPage) {
+        // Use the real view document for namespace resolution if available, otherwise create a minimal fallback
+        const nsDoc = xmlDocument ??
+            new DOMParser().parseFromString('<mvc:View xmlns:mvc="sap.ui.core.mvc" xmlns:macros="sap.fe.macros" xmlns="sap.m"/>', 'text/xml');
+        // Parse content directly so documentElement IS the <macros:Page> element,
+        // matching what appendPageAggregations expects as templateDocument.documentElement.
+        const snippetErrorHandler = (level, message) => {
+            throw new Error(`Unable to parse Page building block snippet. Details: [${level}] - ${message}`);
+        };
+        const snippetMacrosNS = getOrAddNamespace(nsDoc, 'sap.fe.macros', 'macros') || 'macros';
+        const snippetContent = `${content}`.replace(new RegExp(`^<(${snippetMacrosNS}:Page)`), `<$1 xmlns:${snippetMacrosNS}="sap.fe.macros"`);
+        const snippetDoc = new DOMParser({ errorHandler: snippetErrorHandler }).parseFromString(snippetContent, 'text/xml');
+        appendPageAggregations(fs, nsDoc, snippetDoc, fnGenerateId, pageData);
+        const resultNode = snippetDoc.documentElement;
+        viewOrFragmentContent = resultNode ? format(new XMLSerializer().serializeToString(resultNode)) : content;
+    }
     const filePathProps = getFilePathProps(basePath, viewOrFragmentPath);
     // Snippet for fragment xml
     snippets['viewOrFragmentPath'] = {
-        content,
+        content: viewOrFragmentContent,
         language: CodeSnippetLanguage.XML,
         filePathProps
     };

package/dist/building-block/prompts/questions/page.js

@@ -1,6 +1,6 @@
 import { i18nNamespaces, translate } from '../../../i18n.js';
 import { getBuildingBlockIdPrompt, getViewOrFragmentPathPrompt, getAggregationPathPrompt } from '../utils/index.js';
-import { BuildingBlockType } from '../../types.js';
+import { BuildingBlockType, PAGE_TEMPLATE_TYPE_BASIC, PAGE_TEMPLATE_TYPE_FULL } from '../../types.js';
 import { SapShortTextType, SapLongTextType } from '@sap-ux/i18n';
 /**
  * Returns a list of prompts required to generate a page building block.
@@ -12,6 +12,17 @@ export async function getPageBuildingBlockPrompts(context) {
     const t = translate(i18nNamespaces.buildingBlock, 'prompts.page.');
     return {
         questions: [
+            {
+                type: 'list',
+                name: 'buildingBlockData.templateType',
+                message: t('templateType.message'),
+                default: PAGE_TEMPLATE_TYPE_BASIC,
+                choices: [
+                    { value: PAGE_TEMPLATE_TYPE_BASIC, name: t('templateType.basic') },
+                    { value: PAGE_TEMPLATE_TYPE_FULL, name: t('templateType.full') }
+                ],
+                guiOptions: { mandatory: true }
+            },
             getViewOrFragmentPathPrompt(context, t('viewOrFragmentPath.validate'), {
                 message: t('viewOrFragmentPath.message'),
                 guiOptions: {

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

@@ -367,6 +367,8 @@ export interface Table extends BuildingBlock {
  * <macro:Page title="My Page Title" description="My Page Description" />
  * @extends {BuildingBlock}
  */
+export declare const PAGE_AGGREGATIONS: readonly ["breadcrumbs", "navigationActions", "titleContent", "actions", "headerContent", "items", "footer"];
+export type PageAggregationName = (typeof PAGE_AGGREGATIONS)[number];
 export interface Page extends BuildingBlock {
     /**
      * The title of the page.
@@ -376,6 +378,42 @@ export interface Page extends BuildingBlock {
      * The description of the page.
      */
     description?: string;
+    /**
+     * The template type for the page building block.
+     * 'full' generates a full page template with all aggregations and controller stubs.
+     * 'basic' generates a minimal self-closing tag (default behavior).
+     */
+    templateType?: PageTemplateType;
+    /**
+     * Optional mContent strings keyed by aggregation name.
+     * When templateType is 'full', each entry is written as the inner XML of the corresponding aggregation.
+     */
+    aggregations?: Partial<Record<PageAggregationName, string>>;
+}
+export declare const PAGE_TEMPLATE_TYPE_FULL: "full";
+export declare const PAGE_TEMPLATE_TYPE_BASIC: "basic";
+export type PageTemplateType = typeof PAGE_TEMPLATE_TYPE_FULL | typeof PAGE_TEMPLATE_TYPE_BASIC;
+/**
+ * A group of XML nodes representing one Page aggregation element and its preceding sibling comments.
+ * Used when re-ordering aggregation children under a macros:Page element.
+ */
+export type XmlAggregationGroup = {
+    comments: Node[];
+    element: Element;
+    originalIndex: number;
+};
+/**
+ * Configuration for appending a named aggregation to an existing building block element in a view XML file.
+ */
+export interface GenerateBuildingBlockAggregationConfig {
+    /** Path to the view XML file, relative to basePath. */
+    viewPath: string;
+    /** Type of the building block whose aggregation should be appended. Currently only 'Page' is supported. */
+    buildingBlockType: BuildingBlockType;
+    /** Name of the aggregation to append. */
+    aggregationName: PageAggregationName;
+    /** Optional inner XML content for the aggregation. */
+    mContent?: string;
 }
 /**
  * Represents a custom filter to be used inside the FilterBar.

package/dist/building-block/types.js

@@ -20,4 +20,23 @@ export var BuildingBlockType;
 })(BuildingBlockType || (BuildingBlockType = {}));
 export const bindingContextAbsolute = 'absolute';
 export const bindingContextRelative = 'relative';
+/**
+ * Building block used to create a page.
+ * The page building block allows configuration of the title, and description.
+ *
+ * @example
+ * <macro:Page title="My Page Title" description="My Page Description" />
+ * @extends {BuildingBlock}
+ */
+export const PAGE_AGGREGATIONS = [
+    'breadcrumbs',
+    'navigationActions',
+    'titleContent',
+    'actions',
+    'headerContent',
+    'items',
+    'footer'
+];
+export const PAGE_TEMPLATE_TYPE_FULL = 'full';
+export const PAGE_TEMPLATE_TYPE_BASIC = 'basic';
 //# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -20,8 +20,10 @@ export type { FPMConfig } from './app/index.js';
 export { validateBasePath, validateVersion } from './common/validate.js';
 export { createIdGenerator, type IdGeneratorFunction, getRelativeTemplateComponentPath } from './common/file.js';
 export { BuildingBlockType } from './building-block/types.js';
-export type { FilterBar, Form, Chart, Field, FieldFormatOptions, Table, BuildingBlockConfig, Page, CustomColumn, CustomFilterField, CustomFormField, RichTextEditor, ButtonGroupConfig, Action } from './building-block/types.js';
-export { generateBuildingBlock, getSerializedFileContent } from './building-block/index.js';
+export type { FilterBar, Form, Chart, Field, FieldFormatOptions, Table, BuildingBlockConfig, Page, CustomColumn, CustomFilterField, CustomFormField, RichTextEditor, ButtonGroupConfig, Action, PageTemplateType } from './building-block/types.js';
+export { PAGE_TEMPLATE_TYPE_FULL, PAGE_TEMPLATE_TYPE_BASIC, PAGE_AGGREGATIONS } from './building-block/types.js';
+export type { PageAggregationName, GenerateBuildingBlockAggregationConfig } from './building-block/types.js';
+export { generateBuildingBlock, getSerializedFileContent, generateBuildingBlockAggregation } from './building-block/index.js';
 export type { ChartPromptsAnswer, FilterBarPromptsAnswer, FormPromptsAnswer, TablePromptsAnswer, PagePromptsAnswer, RichTextEditorPromptsAnswer, RichTextEditorButtonGroupsPromptsAnswer, BuildingBlockTypePromptsAnswer } from './building-block/prompts/questions/index.js';
 export { PromptsType, PromptsAPI } from './prompts/index.js';
 export type { SupportedGeneratorAnswers, PromptsGroup, Prompts, ValidationResults, Answers, Subset, CodeSnippet } from './prompts/index.js';

package/dist/index.js

@@ -12,7 +12,8 @@ export { enableFPM } from './app/index.js';
 export { validateBasePath, validateVersion } from './common/validate.js';
 export { createIdGenerator, getRelativeTemplateComponentPath } from './common/file.js';
 export { BuildingBlockType } from './building-block/types.js';
-export { generateBuildingBlock, getSerializedFileContent } from './building-block/index.js';
+export { PAGE_TEMPLATE_TYPE_FULL, PAGE_TEMPLATE_TYPE_BASIC, PAGE_AGGREGATIONS } from './building-block/types.js';
+export { generateBuildingBlock, getSerializedFileContent, generateBuildingBlockAggregation } from './building-block/index.js';
 export { PromptsType, PromptsAPI } from './prompts/index.js';
 export { ControllerExtensionPageType } from './controller-extension/types.js';
 export { generateControllerExtension } from './controller-extension/index.js';

package/dist/prompts/translations/i18n.d.ts

@@ -249,6 +249,11 @@ declare const ns1: {
             replaceDefaultButtonGroupsHint: string;
         };
         page: {
+            templateType: {
+                message: string;
+                basic: string;
+                full: string;
+            };
             id: {
                 message: string;
                 validation: string;

package/dist/prompts/translations/i18n.js

@@ -278,6 +278,11 @@ const ns1 = {
             'replaceDefaultButtonGroupsHint': 'Adding button groups replaces the default button groups in the Rich Text Editor with your chosen configuration.'
         },
         'page': {
+            'templateType': {
+                'message': 'Page Layout',
+                'basic': 'Basic',
+                'full': 'Full'
+            },
             'id': {
                 'message': 'Building Block ID',
                 'validation': 'An ID is required to generate the page building block.'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/fe-fpm-writer",
   "description": "SAP Fiori elements flexible programming model writer",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -31,7 +31,7 @@
     "semver": "7.7.4",
     "xml-formatter": "3.7.0",
     "xpath": "0.0.34",
-    "@sap-ux/fiori-annotation-api": "1.0.8",
+    "@sap-ux/fiori-annotation-api": "1.0.9",
     "@sap-ux/i18n": "1.0.1",
     "@sap-ux/project-access": "2.1.2",
     "@sap-ux/logger": "1.0.1"
@@ -44,7 +44,7 @@
     "@types/mem-fs-editor": "7.0.1",
     "@types/semver": "7.7.1",
     "@types/vinyl": "2.0.12",
-    "@sap-ux/ui-prompting": "1.0.3"
+    "@sap-ux/ui-prompting": "1.0.4"
   },
   "engines": {
     "node": ">=22.x"

package/templates/building-block/page/Controller.js

@@ -0,0 +1,17 @@
+sap.ui.define([], function () {
+    'use strict';
+
+    return {
+        onPressHome: function (_event) {},
+
+        onPressPage1: function (_event) {},
+
+        onPressPage2: function (_event) {},
+
+        onFullScreen: function (_event) {},
+
+        onClickAction1: function (_event) {},
+
+        onClickAction2: function (_event) {}
+    };
+});

package/templates/building-block/page/Controller.ts

@@ -0,0 +1,14 @@
+import ExtensionAPI from 'sap/fe/core/ExtensionAPI';
+import Event from 'sap/ui/base/Event';
+
+export function onPressHome(this: ExtensionAPI, _event: Event): void {}
+
+export function onPressPage1(this: ExtensionAPI, _event: Event): void {}
+
+export function onPressPage2(this: ExtensionAPI, _event: Event): void {}
+
+export function onFullScreen(this: ExtensionAPI, _event: Event): void {}
+
+export function onClickAction1(this: ExtensionAPI, _event: Event): void {}
+
+export function onClickAction2(this: ExtensionAPI, _event: Event): void {}

package/templates/building-block/page/View.xml

@@ -1,5 +1,6 @@
 <<%- macrosNamespace %>:Page
     id="<%- data.id %>"<% if (data.title) { %>
     title="<%- data.title %>"<% } %><% if (data.description) { %>
-    description="<%- data.description %>"<% } %>
+    description="<%- data.description %>"<% } %><% if (data.templateType === 'full') { %>
+    showFooter="true"<% } %>
 />

package/templates/building-block/page/actions.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>actions>
+    <!-- Actions aggregation -->
+    <%- mContent %>
+</<%- macrosPrefix %>actions>

package/templates/building-block/page/breadcrumbs.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>breadcrumbs>
+    <!-- Breadcrumbs aggregation -->
+    <%- mContent %>
+</<%- macrosPrefix %>breadcrumbs>

package/templates/building-block/page/footer.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>footer>
+    <!-- Footer aggregation -->
+    <%- mContent %>
+</<%- macrosPrefix %>footer>

package/templates/building-block/page/headerContent.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>headerContent>
+    <!-- Header content aggregation (content after avatar) -->
+    <%- mContent %>
+</<%- macrosPrefix %>headerContent>

package/templates/building-block/page/items.xml

@@ -0,0 +1,9 @@
+<<%- macrosPrefix %>items>
+    <!-- Main content -->
+    <IconTabBar id="iconTabBar<%- aggId %>" class="sapUiResponsiveContentPadding">
+        <items>
+            <IconTabFilter id="iconTabFilter<%- aggId %>" text="Tab 1">
+            </IconTabFilter>
+        </items>
+    </IconTabBar>
+</<%- macrosPrefix %>items>

package/templates/building-block/page/navigationActions.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>navigationActions>
+    <!-- Navigation actions aggregation -->
+    <%- mContent %>
+</<%- macrosPrefix %>navigationActions>

package/templates/building-block/page/titleContent.xml

@@ -0,0 +1,4 @@
+<<%- macrosPrefix %>titleContent>
+    <!-- Title content aggregation (content next to title) -->
+    <%- mContent %>
+</<%- macrosPrefix %>titleContent>