manifest-descriptor-for-applications-components-and-libraries-be0cf40.md

Manifest (Descriptor for Applications, Components, and Libraries)

The manifest (also known as descriptor for applications, components, and libraries, in short: app descriptor) is inspired by the WebApplication Manifest concept introduced by the W3C. The manifest provides a central, machine-readable, and easy-to-access location for storing metadata associated with an application, an application component, or a library.

In general, the manifest describes the behavior of an app through attributes. It doesn't directly influence that behavior itself for the most part. When a section in the manifest does affect the behavior of an app, this is described in the API Reference. for the corresponding namespace.

The data of the manifest is stored in JSON format in the manifest.json file. The developer creates the file with attributes in different namespaces. It contains, for example, the app ID, the version, the data sources used, along with the required components and libraries. The existence of the manifest.json file must be declared in the component metadata, which is then delivered as part of the application archive. After delivery, the file is read-only.

General Information

There is a new version of the manifest when the schema is changed. In the following table, you can see how the OpenUI5 version is related to the manifest version and the value of _version.

Manifest Release and OpenUI5 Version

Manifest Release	OpenUI5 Version	_version
Version 2	>=1.30	1.1.0
Version 3	>=1.32	1.2.0
Version 4	>=1.34	1.3.0
Version 5	>=1.38	1.4.0
Version 6	>=1.42	1.5.0
Version 7	>=1.46	1.6.0
Version 8	>=1.48	1.7.0
Version 9	>=1.50	1.8.0
Version 10	>=1.52	1.9.0
Version 11	>=1.54	1.10.0
Version 12	>=1.56	1.11.0
Version 13	>=1.58	1.12.0
Version 14	>=1.61	1.13.0
Version 15	>=1.62	1.14.0
Version 16	>=1.66	1.15.0
Version 17	>=1.70	1.16.0
Version 18	>=1.71	1.17.0
Version 19	>=1.74	1.18.0
Version 20	>=1.75	1.19.0
Version 21	>=1.76	1.20.0
Version 22	>=1.77	1.21.0
Version 23	>=1.78	1.22.0
Version 24	>=1.79	1.23.0
Version 25	>=1.80	1.24.0
Version 26	>=1.81	1.25.0
Version 27	>=1.82	1.26.0
Version 28	>=1.83 (OpenUI5 1.83 was not released, see 2979657)	1.27.0
Version 29	>=1.84	1.28.0
Version 30	>=1.85	1.29.0
Version 31	>=1.86	1.30.0
Version 32	>=1.87	1.31.0
Version 33	>=1.88	1.32.0
Version 34	>=1.90	1.33.0
Version 35	>=1.92	1.34.0
Version 36	>=1.93	1.35.0
Version 37	>=1.95	1.36.0
Version 38	>=1.96	1.37.0
Version 39	>=1.98	1.38.0
Version 40	>=1.99	1.39.0
Version 41	>=1.100	1.40.0
Version 42	>=1.101	1.41.0
Version 43	>=1.102	1.42.0
Version 44	>=1.103	1.43.0
Version 45	>=1.104	1.44.0
Version 46	>=1.105	1.45.0
Version 47	>=1.106	1.46.0
Version 48	>=1.107	1.47.0
Version 49	>=1.108	1.48.0
Version 50	>=1.109	1.49.0
Version 51	>=1.110	1.50.0
Version 52	>=1.111	1.51.0
Version 53	>=1.112	1.52.0
Version 54	>=1.113	1.53.0
Version 55	>=1.114	1.54.0
Version 56	>=1.115	1.55.0
Version 57	>=1.116	1.56.0
Version 58	>=1.117	1.57.0
Version 59	>=1.118	1.58.0
Version 60	>=1.119	1.59.0
Version 61	>=1.120	1.60.0
Version 62	>=1.121	1.61.0
Version 63	>=1.122	1.62.0
Version 64	>=1.123	1.63.0
Version 65	>=1.124	1.64.0
Version 66	>=1.126	1.65.0
Version 67	>=1.129	1.66.0
Version 68	>=1.130	1.67.0
Version 69	>=1.131	1.68.0
Version 70	>=1.132	1.69.0
Version 71	>=1.133	1.70.0
Version 72	>=1.134	1.71.0
Version 73	>=1.134	1.72.0

For more information on the new fields introduced in each version, check out Migration Information for Upgrading the Manifest File

Manifest First Function

The component factory function Component.create, as introduced with 1.58, loads the manifest.json by default before the component instance is created. With this, you can preload the dependencies (libraries and components) and, thus, improve the performance for loading the component. The preload is also available for models, which can be flagged for preload during component loading.

The manifest option allows you to configure when and from where the manifest is loaded:

• Default, equivalent to setting manifest to true.

  // "Component" required from module "sap/ui/core/Component"
  // load manifest.json from default location and evaluate it before creating an instance of the component 
  Component.create({
    name: "sap.my.component",
  });

• Specify an alternative URL as parameter for manifest for the component factory function:

  // "Component" required from module "sap/ui/core/Component"
  // load via manifest URL
  Component.create({
    name: "sap.my.component",
    manifest: "any/location/sap/my/component/manifest.json"
  });

• There are two possible scenarios for setting the manifest flag to false:

  1. The component defines manifest: "json" in its Component Metadata.

     In this case, the manifest is loaded and evaluated after the Component controller. All dependencies defined in the manifest will then also be loaded. Afterwards, the Component is instantiated.

  2. The component does not define manifest: "json" in its Component Metadata.

     This is typically the case for older legacy Components without a manifest. In this case, only the Component's class metadata is evaluated. No additional manifest file will be loaded.

  // "Component" required from module "sap/ui/core/Component"
  // load component without loading a manifest first
  //  - Case 1: the manifest.json is loaded after the Component controller
  //  - Case 2: no manifest.json is loaded (legacy)
  Component.create({
    name: "sap.my.component",
    manifest: false
  });

Note:

When you enable manifest, all legacy component metadata needs to be migrated into the manifest for applications/components. Only those entries in the manifest for components will be respected by the component and all other entries will be ignored.

Special ui5:// URLs

Inside the manifest, you can use special URLs prefixed with ui5://. These URLs will be resolved automatically during component startup before any models are created.

The ui5:// URLs have the following properties:

• only absolute URLs are allowed, e.g. ui5://my/path/to/sample, but not ui5:my/app/path,
• all URL prefixes to be used inside a ui5:// URL must be registered on the UI5 loader beforehand (see the example below),
• sap.ui5/resourceRoots can be part of a ui5:// URL,
• the component factory Component.create takes care of defining the resource roots before any ui5:// URLs are resolved.

Example

One common use case is the resolution of local annotation files. By default the local annotation files are resolved relative to the manifest. When using a ui5:// URL, you can enforce a different resolution, e.g. to a server-absolute URL.

In this sample, we make sure that the component location is registered as a path on the UI5 loader. Additionally, we assume that the host system ishttp://localhost:8080 :

sap.ui.loader.config({
    paths: {
        "my/url/prefix": "this/url/is/reachable"
    }
})

The following snippet shows a sample annotation file configuration in the sap.app/dataSources section of the manifest:

{
    ...
    "sap.app": {
         "dataSources": {
             "OData": {
                "uri": "/path/to/odata/service",
                "type": "OData",
                "settings": {
                    "odataVersion": "2.0",
                    "annotations": ["annotations"]
                    ...
                }
            },
            ...
            "annotations": {
                "uri": "ui5://my/url/prefix/annotations.xml",
                "type": "ODataAnnotation"
            }
            ...
         }
    }
    ...
}

During startup of the respective component the resolution of the ui5:// URL for the sample annotation will look like this:

ui5://my/url/prefix/annotations.xml

is resolved to:

http://localhost:8080/this/url/is/reachable/annotations.xml

Manifest Content

Note:

You can find an example manifest.json file with sample code for the manifest content here.

The content for the is contained in the following namespaces: without, sap.app, sap.ui, and sap.ui5 . The following tables show the application-specific attributes provided by the respective namespaces:

No Namespace

sap.app

sap.ui

sap.ui5

sap.card

_version

No Namespace

Attributes in the without namespace

Attribute	Description
start_url	Start page of your app, if available
$schema	JSON schema URI

sap.app

Attributes in the mandatory sap.app namespace

Attribute	Description
id	A mandatory attribute that has to be provided in dot notation and specifies an ID for the project that must be unique in the system. It must match the namespace provided in the corresponding Component.js. If, for example, a module is instantiated there as follows: return UIComponent.extend("sap.ui.demo.walkthrough.Component", { metadata : { manifest: "json" }, ... then its id would be sap.ui.demo.walkthrough It's used as a reference point for most operations involving the manifest. If the project is the app variant of an existing application, sap.app/id is the ID of this app variant. The ID of the underlying application is then provided in sap.ui5/componentName. Note: The ID must not exceed 70 characters. It must be unique. In case of sap.app/type=application, the sap.app/id corresponds to the id of the UI5 component.
type	A mandatory attribute. The following values are possible: application: use if your manifest.json describes a UI5 application. For an example how to use a manifest.json for UI5 applications, see Step 10: Descriptor for Applications component: use if your manifest.json describes a reuse component that is used in several apps. For further reuse component-specific configuration options, see Manifest for Components (Inside Libraries). library: use if your manifest.json describes a UI5 library. For further library-specific configuration options, see Manifest for Libraries. card: use if your manifest.json describes a UI5 card.For further card-specific configuration options, see Integration Cards.
i18n	The i18n property is an optional attribute and contains one of the following: A URL string to the properties file that contains the text symbols for the manifest; the URL is interpreted relative to the manifest. An object that has been defined as described in Supported Locales and Fallback Chain and Terminologies. Note: The sap.app/i18n section only supports terminologies for Components. Library manifests do not support additional terminologies. If the manifest contains placeholders in {{...}} syntax, but no i18n attribute has been provided, the default value i18n/i18n.properties is used to request a ResourceBundle.
applicationVersion	Mandatory version of the app (semantic version with the following format major.minor.patch)
embeds	Array of relative paths to the nested manifest.json files; attribute is mandatory if a nested manifest.json exists
embeddedBy	Relative path back to the manifest.json file of an embedding component or library; attribute is mandatory for a nested manifest.json
title	Mandatory attribute; to make this property language dependent (recommended), use a key in double curly brackets: {{key}}
subTitle	Subtitle; to make this property language dependent (recommended), use a key in double curly brackets: {{key}}
shortTitle	Short version of the title; to make this property language dependent (recommended), use a key in double curly brackets: {{key}}
info	Needed for CDM (Common Data Model) conversion of tiles; to make this property language dependent (recommended), use a key in double curly brackets: {{key}}
description	Description; to make this property language dependent (recommended), use a key in double curly brackets: {{key}}
tags	Contains the following: An array of keywords; either text or a language-dependent entry to be specified via {{…}} syntax, for example "keywords": ["{{keyWord1}}","{{keyWord2}}"]. An array of technicalAttributes (general technical attributes, for example, technical catalog, upper case and language-independent attributes).
dataSources	Unique key/alias for specifying the used data sources; contains the following information: uri: Mandatory relative URL in the component; takes embeddedBy into account, if filled, or the server absolute of the data source, for example "/sap/opu/odata/snce/PO_S_SRV;v=2/". uri should always be given in lower case. type: Supported types: OData (default) ODataAnnotation INA XML JSON FHIR http WebSocket customType (As of 1.77): true/false; if true, there is no validation on the type attribute settings: Data source type-specific attributes (key, value pairs), which are: odataVersion: 2.0 (default), 4.0 localUri: Relative URL to local metadata document or annotation URI annotations: Array of annotations which references an existing data source of type ODataAnnotation under sap.app/dataSources maxAge: Indicates the number of seconds the client is willing to accept with regard to the age of the data that is requested objects: Dictionary of (catalog) objects offered by the INA datasource (as of 1.92) consisting of: objectName: Mandatory CDS view name / analytical query name objectType - mandatory type of object (2C<DDICNAME> or CDSViewName); values: query, cdsprojectionview, view, inamodel packageName: Name of the package schemaName: Name of the schema
cdsViews	Array of directly used CDS views This attribute is optional and only added if used via INA protocol directly, not if used via OData service.
offline	Indicates whether the app is running offline; default is false (online)
sourceTemplate	If an app has been generated from a template, this attribute is filled automatically by the generation tool: id: Mandatory ID of the template from which the app was generated version: Mandatory version of the template from which the app was generated toolsId: ID generated by the tool
openSourceComponents	Array of directly used open source libraries for documentation purposes; not used when open source libraries are used via OpenUI5 capsulation name: Mandatory name of the open source component version: Required if the open source component is part of the app; not required if the open source component is part of the OpenUI5 dist layer packagedWithMySelf: Indicates if the open source component is part of the app (true) or not (false)
resources	Relative URL as a reference to a file (naming convention is resources.json) that contains a list of all resources needed by the app (all resources inside the app); the file is generated in an SAP Fiori tools (in SAP Business Application Studio) build step. For a description of resources.json, see The resources.json File.

sap.ui

Attributes in the mandatory sap.ui namespace

Attribute	Description
technology	A mandatory attribute that specifies the UI technology; value is UI5
icons	Contains object with app-specific icons, which are: icon: Icon of the app, can be chosen from Icon Explorer . favIcon: ICO file to be used inside the browser and for desktop shortcuts Note: favIcon is not set automatically by the framework. The icons can be set manually using the sap/ui/util/Mobile module and the setIcons function. phone: 120x120 pixel version for iPhones with low pixel density phone@2: 180x180 pixel version for iPhones with high pixel density tablet: 152x152 pixel version for iPads with low pixel density tablet@2: 167x167 pixel version for iPads with high pixel density
deviceTypes	Mandatory; contains objects with device types on which the app is running, such as: desktop: Indicator for whether desktop devices are supported, true, false tablet: Indicator for whether tablet devices are supported, true, false phone: Indicator for whether phone devices are supported, true, false

sap.ui5

The sap.ui5 namespace is aligned with the former concept of component metadata and contributes the following OpenUI5-specific attributes for the manifest, see Migrating from Component Metadata to Manifest for more details.

Attributes in the sap.ui5 namespace

Attribute	Description
resources	Specifies additional css and js resources of the Component. CSS files are added to the head of the HTML page as a link tag. JavaScript files are loaded by the require mechanism. Two settings can be defined per resource: uri (mandatory): URLs are resolved relative to the Component, taking the embeddedBy setting into account (if filled). id (optional): Only for css resources; the id for a CSS file's <link> element. Note: Since 1.94 the usage of js resources is deprecated. Please use regular dependencies instead.
dependencies	Mandatory; specifies the external dependencies that are loaded by the OpenUI5 core during the initialization phase of the component and used afterwards. These are the following libraries or components: minUI5Version: Mandatory; Minimum version of OpenUI5 that your component requires; this information ensures that the features of the OpenUI5 runtime version of the component are available. This must be either a specific version or an array of versions where each major version can only be included once. If you specify an array that contains more than one version, and if version 1 is included, it must be at least 1.120.x. As OpenUI5 does not currently enforce use of the correct version, the minUI5Version is used for information purposes only. If the minimum OpenUI5 version criteria is not fulfilled, a warning is issued in the console log. libs: ID (namespace) of the libraries that the OpenUI5 core should load for use in the component. If your app requires a minimum version of the lib, specify the minVersion for information purposes. Specify lazy to indicate that the lib shall be lazy loaded. components: ID (namespace) of the components that the OpenUI5 core should load for use in your component. If your app requires a minimum version of the component, specify the minVersion for information purposes. Specify lazy to indicate that the component shall be lazy loaded. For more information, see Manifest Dependencies to Libraries and Components.
componentUsages	Specifies the used components with the a unique key/alias. Contains the following: name: Mandatory name of the reuse component settings: Settings of the component componentData: Component data of the component lazy: Indicates whether the component usage should be lazily loaded. Default value: true For more information, see: Using and Nesting Components.
models	Note: For component manifests only. Libraries can not define models. Defines models that should be created or destroyed along the component's lifecycle. The key represents the model name. Use an empty string ("") for the default model. type: Model class name uri: Relative URL in the component, taking embeddedBy into account if filled, or server for absolute model settings: Object that is passed to the model constructor. Example: You can overwrite the default binding mode with the defaultBindingMode attribute (enumeration of type sap.ui.model.BindingMode, with values. Default, OneTime, OneWay, TwoWay). For OData models constructor see the following: sap.ui.model.odata.v2.ODataModel sap.ui.model.odata.v4.ODataModel For ResourceModel constructor see: sap.ui.model.resource.ResourceModel The attribute enhanceWith can be specified with bundleUrl, bundleUrlRelativeTo (either component (default) or manifest) or bundleName to provide a list of additional resource bundle configurations to enhance the ResourceModel with. Additional attributes can be found in Supported Locales and Fallback Chain and Terminologies. dataSource: String of key or alias from sap.app dataSources to reference an existing data source; the type, uri and settings properties are set according to the data source's type, uri and settings (if not already defined). If the type under sap.app dataSources is OData, an OData Model V2 is created automatically. If you need an OData Model V1, specify the type as well. preload: Optional; Boolean with true, false (default) Defines whether or not the model is initialized (preloaded) before the component instance is created and while loading the component preload and its dependencies. For more information, see Manifest Model Preload.
rootView	Specifies the root view that shall be opened; can be the view name as a string for XML views, or the view configuration object with viewName for the view name as a string (see sap.ui.core.mvc.View.create) and type for the type (enumeration of sap.ui.core.mvc.ViewType), id, async, and other properties of sap.ui.core.mvc.view.
autoPrefixId	true, false (default), Enables the auto prefixing for the UIComponent for IDs of ManagedObjects (controls or elements) which are created in the context of the createContent function, or any other invocation of the Component.prototype.runAsOwner() function (for example a component's router uses this method when creating new views). In former OpenUI5 releases this prefixing of the ID needed to be done with oComponent.createId by overwriting the method getAutoPrefixId. The same can now be achieved declaratively by setting autoPrefixId to true.
handleValidation	Possible values: true or false (default); used to enable or disable validation handling by the message manager for this component, see Error, Warning, and Info Messages
config	Static configuration; specify the name-value pairs that you need in your component.
routing	Provides configuration parameters for route and router, see Routing and Navigation
extends	Used to extend another component. component: ID (namespace) of the component being extended minVersion: Specifies the minimum version of the component being extended, for information purposes if your app requires a minimum version of the component extensions: Component or view extensions, which enable you to replace and extend views and controllers and also to modify the views, see Extending Apps
contentDensities	Mandatory; contains an object with the content density modes that the app supports, see Content Densities compact: Mandatory; indicates whether compact mode is supported (true, false) cozy: Mandatory; indicates whether cozy mode is supported (true, false)
resourceRoots	Map of URL locations keyed by a resource name prefix; only relative paths inside the component are allowed and no ".." characters This attribute is intended for actual sub-packages of the component only, meaning that it must not be used for the component namespace itself. Note: When loading with manifest first(by using the property manifest), the resourceRoots are evaluated before the component controller is loaded. Otherwise, the defined resource roots will be registered after the component controller is loaded and do not affect the modules being declared as dependencies in the component controller.
componentName	An optional attribute that only has to be provided if your project is a variant of an existing application. In this case the componentName has to contain the sap.app/id of the existing application which is the basis of your variant.
library/i18n	Note: For library manifests only. Determines whether the library contains an i18n resource. The value can be either a boolean, a string, or an object. A string value represents a bundle URL. Relative URLs are always resolved to the library origin. If no value is set, the default messagebundle.properties file is loaded. An object value can contain additional resource bundle configuration, e.g. terminologies and supported locales. For the supported features and for sample definitions, see the respective entries at Terminologies (without bundleUrlRelativeTo) and Supported Locales and Fallback Chain . Note: This attribute is beneficial if the name of the main resource bundle (properties file) used by your UI5 library differs from the default name messagebundle.properties
commands	Specifies provided commands with a unique key/alias. Contains: shortcut: String that describes a key combination. When the user presses the key combination, the command is triggered. The name of the command that contains the shortcut definition acts as a prerequisite for using the command property of the sap.ui.core.CommandExecution module. For more information, see the API Reference: sap.ui.core.CommandExecution.

sap.card

Attributes in the sap.card namespace

Attribute	Description
type	Describes the card type; possible values are list and analytical
header	Specifies the card's header area
content	Specifies the type-dependent card content

_version

• On root level (no namespace): Describes the manifest format version (mandatory). Needs to be updated when migrating to a new manifest format version, see Migrating from Component Metadata to Manifest

• Inside namespace: Describes the namespace format version (optional from version 1.38 on)

Manifest Schema

The newest flattened JSON schema is available on the SAP Open Source GitHub at https://github.com/sap/ui5-manifest/ under Apache-2.0 License. It can be used to enable schema validation, code completion, and documentation.

Example

Current version of the manifest.json

Note:

The following sample contains the full scope of all available manifest properties. Some properties might not be applicable for all manifest.json variants. For example, the sap.ui5/models section is not supported for library manifests. For more information, see the above listing of namespaces and properties.

{
    "_version": "1.72.0",
 
    "start_url": "index.html",
 
    "sap.app": {
        "id": "sap.fiori.appName",
        "type": "application",
        "i18n": "i18n/i18n.properties",
        "applicationVersion": {
            "version": "1.2.2"
        },
        "embeds": ["mycomponent1", "subpath/mycomponent2"],
        "embeddedBy": "../../",
        "title": "{{title}}",
        "subTitle": "{{subtitle}}",
        "shortTitle": "{{shorttitle}}",
        "description": "{{description}}",
        "info": "{{info}}",
        "tags": {
            "keywords": ["{{keyWord1}}", "{{keyWord2}}"],
            "technicalAttributes": ["ATTRIBUTE1", "ATTRIBUTE2"]
        },
        "dataSources": {
            "equipment": {
                "uri": "/sap/opu/odata/snce/po_s_srv;v=2/",
                "type": "OData",
                "settings": {
                    "odataVersion": "2.0",
                    "annotations": ["equipmentanno"],
                    "localUri": "model/metadata.xml",
                    "maxAge": 360
                }
            },
            "equipmentanno": {
                "uri": "/sap/bc/bsp/sap/nscbn_anf_eam/bscbn_equipment_srv.anno.xml",
                "type": "ODataAnnotation",
                "settings": {
                    "localUri": "model/annotations.xml"
                }
            }
        },
        "cdsViews": [
            "VIEW1", "VIEW2"
        ],
        "resources": "resources.json",
        "offline": true,
        "sourceTemplate": {
            "id": "sap.ui.ui5-template-plugin.1worklist",
            "version": "1.0.0",
            "toolsId": "C12345678"
        },
        "destination": {
            "name": "SAP_ERP_FIN"
        },
        "openSourceComponents": [{
            "name": "D3.js",
            "packagedWithMySelf": false
        }]
    },
 
    "sap.ui": {
        "technology": "UI5",
        "icons": {
            "icon": "sap-icon://add-contact",
            "favIcon": "icon/F1373_Approve_Purchase_Orders.ico",
            "phone": "icon/launchicon/57_iPhone_Desktop_Launch.png",
            "phone@2": "icon/launchicon/114_iPhone-Retina_Web_Clip.png",
            "tablet": "icon/launchicon/72_iPad_Desktop_Launch.png",
            "tablet@2": "icon/launchicon/144_iPad_Retina_Web_Clip.png"
        },
        "deviceTypes": {
            "desktop": true,
            "tablet": true,
            "phone": false
        }
    },
 
    "sap.ui5": {
        "resources": {
            "css": [{
                "uri": "component.css",
                "id": "componentcss"
            }]
        },
        "dependencies": {
            "minUI5Version": "1.134.0",
            "libs": {
                "sap.m": {
                    "minVersion": "1.34.0"
                },
                "sap.ui.commons": {
                    "minVersion": "1.34.0",
                    "lazy": true
                }
            },
            "components": {
                "sap.ui.app.other": {
                    "minVersion": "1.1.0",
                    "lazy": true
                }
            }
        },
        "componentUsages": {
            "myusage": {
                "name": "my.used",
                "lazy": false,
                "settings": {},
                "componentData": {}
            }
        },
        "models": {
            "i18n": {
                "type": "sap.ui.model.resource.ResourceModel",
                "uri": "i18n/i18n.properties",
                "settings": {
                    "enhanceWith": [{
                        "bundleUrl": "i18n/i18n.properties",
                        "bundleUrlRelativeTo": "manifest"
                    }]
                }
            },
            "equipment": {
                "preload": true,
                "dataSource": "equipment",
                "settings": {}
            }
        },
        "rootView": {
            "viewName": "sap.ui.test.view.Main",
            "id" : "rootView",
            "async": true,
            "type": "XML"
        },
        "handleValidation": true,
        "config": {
 
        },
        "routing": {
 
        },
        "extends": {
            "component": "sap.fiori.otherApp",
            "minVersion": "0.8.15",
            "extensions": {}
        },
        "contentDensities": {
            "compact": true,
            "cozy": false
        },
        "resourceRoots": {
            ".myname": "./myname"
        },
        "componentName": "sap.fiori.appName",
        "library": {
            "i18n": true
        },
        "commands": {
            "Save": {
                "shortcut": "Ctrl+S"
            }
        }
    },

 

    "sap.fe": {},
    "sap.card": {}
}

For the following namespaces, the indicated teams are responsible:

• sap.fe - in SAP Fiori elements responsibility

• sap.card - in SAPUI5 responsibility

Declaration in Component Metadata

The component declares the existence of the manifest by specifying manifest: "json" in the component metadata. Setting this flag makes the component load the manifest.json file and read the relevant entries for OpenUI5. This metadata is used to define the dependencies that need to be loaded in order to start the component. The following code snippet shows how to add the manifest link:

sap.ui.define([
	"sap/ui/core/UIComponent"
], (UIComponent) => {
	"use strict";
	return UIComponent.extend("my.sample.Component", {
		metadata  : { 
			manifest: "json",
			interfaces: [
				"sap.ui.core.IAsyncContentCreation"
			]
		}
	});
});

OpenUI5 API

At runtime, the manifest content can be accessed from the component via the following sap.ui.core.Component APIs:

// Given: oComponent === instance of sap.ui.core.Component (e.g. returned by sap.ui.core.mvc.Controller#getOwnerComponent)
oComponent.getManifest(); // returns reference to the entire manifest object if it exists; otherwise returns null
oComponent.getManifestEntry("sap.app"); // returns reference to the configuration section of the manifest
oComponent.getManifestEntry("/sap.ui5/dependencies/libs"); // returns reference or value of the manifest configuration by path; the syntax must start with a slash

sap.ui.core.UIComponent

Component Metadata