granite:commonAttrs - Implemenation difference b/w Coral UI 2 and Coral UI 3

Out of the 3 differences between Granite Components based on Coral UI 2 and Coral UI 3, we are done with Validation change. In this post, we will get insights of the implementation change in common attributes (granite:commonAttrs)

Common Attributes:
Concept of common attributes is similar to HTML global attributes. (global attributes are those that are common to all HTML elements).
For Granite UI based components, list of common attributes are highlighted here.

Change done on Coral UI3 : Common attributes(say granite:class) are strictly implemented to replace existing properties (say class)

We will consider a Touch UI dialog which uses CoralUI2 and Coral UI3 textfield and understand the difference in terms of implementation and usage.
Out of the attributes listed in above link, most commonly used are class, id, title and data related attributes. Hence the same is considered for illustration.

Granite Coral UI2 Textfield :
Resource Path: /libs/granite/ui/components/foundation/form/textfield.

  • In Touch UI dialog, if this resourceType is used, we can add additional properties to the textfield node like class, id, title and other custom properties and it will be available in the generated textfield markup. (custom properties will be available in the form of data-* attributes)
  • Screenshot of dialog and generated markup related to this is added under Screenshots A.
Granite Coral UI3 Textfield:
Resource Path: /libs/granite/ui/components/coral/foundation/form/textfield

  • If this resourceType is used and if we would like to add class/id/title attributes, then we need to add property in the naming convention of granite:class/granite:id/granite:title respectively.
  • For additional custom properties, we need to add a node under the text node in the name "granite:data" and add properties to this node which would then be available in the markup in the form of data-* attributes.
  • Adding properties in the name of "class/id/any custom property" directly on the text node will not be available in the markup (this is the change done in terms of usage)
  • Screenshot of dialog and generated markup related to this is added under Screenshots B.

Component level Implementation Logic:

  • Granite UI's component config (com.adobe.granite.ui.components.Config) is used to retrieve the properties(that we add as part of the node where we use Granite UI component as a resourceType)
  • These properties are then built up as attributes to the HTML tag using Granite UI's Attribute Builder (com.adobe.granite.ui.components.AttrBuilder)
  • In Coral UI2, properties in the name of class ,id, rel and other custom properties are explicitly added to AttrBuilder object whereas in Coral UI3, this explicit logic is not available -> impact being properties in the name of "class" will not be accepted instead "granite:class" will be picked
Screenshots for Reference:
Screenshots A: (CoralUI 2 Textfield)
Custom property: textlength is added. 


Generated markup: (textlength is added as data-textlength attribute. class, id and title are added as is)


Screenshots B: (Coral UI 3 Textfield)
Custom property:  node named granite:data is added below the text node and custom property is then added in granite:data node. (in this case, textlength is the custom property)
  • Though we add a property named "class"(txt-class) for CoralUI 3, the same will not be available in the generated markup. Refer below markup screenshot. 


granite:data node for custom properties:

Generated markup:


Comments

Post a Comment

Popular posts from this blog

Embedding Third party dependency/OSGi bundle in AEM application hosted in AEMasCS

Image
This post illustrate the ways of embedding third party dependency in AEM maven project. Steps are mentioned considering the project structure to be followed for AEMasCS while the same can be followed for classic versions too.  Before we begin, I would like to explain the scenario of including a dependency in our AEM maven project.  When we would like to make use of an API that is not already available in our project, we look for that in maven-central repository and specify the dependency in main pom.xml and desired module's pom.xml file. (Lets say, AWS S3 Java SDK V2 dependency) Upon updating the project in the IDE, we would see our class files (making use of those APIs) are compiled/build successfully without any errors.  Now, in the context of AEM/OSGi environment, when the same package and hence the bundle is deployed to AEM instance, dependencies that we added new might not be resolved/available in the OSGi as a bundle. Something like the below This indicates that the...
Read more

OSGI Factory Configuration implementation

OSGI Factory configuration is used to have many instances of an OSGI config (represented/identified via an identifier) for the single OSGI service/PID. Most often used OOB Factory configurations for example: Logger Factory/writer configuration (for log statements) Service user Mapper service Amendment (for using service resource resolver in projects) Few sample real time use case for the need of OSGI factory config: For multi tenant projects, if we have generic service used across tenants with properties/attributes specific to tenant. For single tenant, generic service targeting all locales with properties/attributes specific to locale. (where generic service -> holds logic in the lines of calling third party service for retrieving/updating information.) Implementation: ( In terms of OSGI R6 annotations ): Create Object Class Definition(OCD) defining desired properties for the OSGI service. - OSGIFactoryConfigOCD.java OSGI Service/Factory service to retrieve ...
Read more

Embed Third party dependency using bnd-maven-plugin

Image
This post explains the use of bnd-maven-plugin to embed third party dependency  Two main instructions of bnd-maven-plugin that serves the purpose are detailed below.  -conditionalpackage  pick packages from respective library and copy them in the bundle. Any dependencies of those copied packages will also be copied if they match the selectors. This means we need to explicitly list all the Java package names of desired dependency as part of this instruction (including its transitive dependencies) More about conditionalpackage instruction from official docs -  https://bnd.bndtools.org/instructions/conditionalpackage.html -includeresource  For including resource inline -includeresource: @artifactId-version.jar!/* For embedding as a jar with an entry in bundle class path -includeresource: artifactId-version.jar;lib:=true For several other possible combinations for including the resource, please check - https://bnd.bndtools.org/instructions/includeresource.html Wi...
Read more