@jahia/javascript-modules-library 0.5.5 → 0.6.0

package/dist/core/server/utils/urlBuilder/urlBuilder.d.ts

@@ -1,25 +1,62 @@
+import type { JCRNodeWrapper } from "org.jahia.services.content";
 import type { RenderContext, Resource } from "org.jahia.services.render";
 /** Initialize the registry with default url builders */
 export declare function initUrlBuilder(): void;
 /**
- * Provide URL generation for contents/files If parameters are not valid, or if a node couldn't be
- * found, it will log an warning and return '#'
+ * Generate a Jahia url for the provided node.
  *
- * @param renderContext The current renderContext
- * @param currentResource The current resource
  * @returns The final URL
  */
-export declare function buildUrl(props: {
-    /** The path of the resource to build the URL for */
-    value?: string;
-    /** The path of the resource to build the URL for */
-    path?: string;
-    /** The parameters to append to the URL */
+export declare function buildNodeUrl(
+/** The node to build the URL for */
+node: JCRNodeWrapper, config?: {
+    /** The querystring parameters to append to the URL */
     parameters?: Record<string, string>;
-    /** The mode to use to build the URL */
-    mode?: string;
-    /** The language to use to build the URL */
+    /**
+     * The mode to use to build the URL. Defines the mode or override the one provided by the
+     * renderContext.
+     */
+    mode?: "edit" | "preview" | "live";
+    /**
+     * The language to use to build the URL. Defines the languages or overrides the one provided by
+     * the current resource
+     */
     language?: string;
-    /** The extension to use to build the URL */
+    /**
+     * The extension to use to build the URL. Defines the extension or overrides the one provided by
+     * the current resource
+     */
     extension?: string;
-}, renderContext: RenderContext, currentResource: Resource): string;
+}, context?: {
+    /** Provided in react context, but you need to provide one otherwise. * */
+    renderContext?: RenderContext;
+    /** Provided in react context, you need to provide one otherwise. * */
+    currentResource?: Resource;
+}): string;
+/**
+ * Build a URL for a file in a module. Note that to be accessible, the folder that contains the file
+ * must be part of the jahia.static-resources in package.json.
+ *
+ * The URL must not be absolute (start with a / or a protocol).
+ */
+export declare function buildModuleFileUrl(
+/** Relative path of the file from the module's root (examples: css/my.css, images/myImage.webp) */
+filePath: string, config?: {
+    /** Defines a custom module name to access its files */
+    moduleName?: string;
+    /** Querystring parameters to append to the URL */
+    parameters?: Record<string, string>;
+}, context?: {
+    /** Provided in react context, you need to provide one (or the module name) otherwise. */
+    renderContext?: RenderContext;
+}): string;
+/** Build an url for any endpoint on the server (/cms/*, /graphql, ect). */
+export declare function buildEndpointUrl(
+/** Endpoint to call */
+endpoint: string, config?: {
+    /** Querystring parameters to append to the URL */
+    parameters?: Record<string, string>;
+}, context?: {
+    /** Provided in react context, you need to provide one otherwise. */
+    renderContext?: RenderContext;
+}): string;

package/dist/globals.d.ts

@@ -17,6 +17,7 @@ declare module "virtual:jahia-server" {
   import type {
     ConfigHelper,
     GQLHelper,
+    JcrHelper,
     OSGiHelper,
     RegistryHelper,
     RenderHelper,
@@ -28,6 +29,8 @@ declare module "virtual:jahia-server" {
   const server: {
     /** This helper provides access to OSGi configuration */
     config: ConfigHelper;
+    /** This helper allows to perform JCR operations */
+    jcr: JcrHelper;
     /** This helper provides access Jahia's GraphQL API, to execute queries and mutations */
     gql: GQLHelper;
     /** This helper provides access to OSGi bundle for resource loading and service access */

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { RenderInBrowser } from "./core/server/components/render/RenderInBrowser.js";
 export { HydrateInBrowser } from "./core/server/components/render/HydrateInBrowser.js";
 export { Render } from "./core/server/components/render/Render.js";
+export { RenderChild } from "./core/server/components/render/RenderChild.js";
+export { RenderChildren } from "./core/server/components/render/RenderChildren.js";
 export { AbsoluteArea } from "./core/server/components/AbsoluteArea.js";
 export { AddContentButtons } from "./core/server/components/AddContentButtons.js";
 export { AddResources } from "./core/server/components/AddResources.js";
@@ -11,18 +13,19 @@ export { registerJahiaComponents } from "./core/server/framework/register.js";
 export { useGQLQuery } from "./core/server/hooks/useGQLQuery.js";
 export { useJCRQuery } from "./core/server/hooks/useJCRQuery.js";
 export { useServerContext, ServerContextProvider } from "./core/server/hooks/useServerContext.js";
-export { useUrlBuilder } from "./core/server/hooks/useUrlBuilder.js";
 export { getChildNodes } from "./core/server/utils/jcr/getChildNodes.js";
-export { getNodeFromPathOrId } from "./core/server/utils/jcr/getNodeFromPathOrId.js";
 export { getNodeProps } from "./core/server/utils/jcr/getNodeProps.js";
 export { getNodesByJCRQuery } from "./core/server/utils/jcr/getNodesByJCRQuery.js";
-export { buildUrl, initUrlBuilder } from "./core/server/utils/urlBuilder/urlBuilder.js";
+export { buildEndpointUrl, buildNodeUrl, buildModuleFileUrl, initUrlBuilder, } from "./core/server/utils/urlBuilder/urlBuilder.js";
+export { getSiteLocales } from "./core/server/utils/i18n.js";
 export { buildNavMenu } from "./nav/server/navBuilder/navBuilder.js";
+export type { MenuEntry } from "./nav/server/navBuilder/navBuilder.js";
 export { default as server } from "virtual:jahia-server";
 
 // Include declarations for all Java types
 export * from "./globals";
 export * from "./java.io";
+export * from "./java.lang";
 export * from "./java.net";
 export * from "./java.security";
 export * from "./java.util";

package/dist/java.io.d.ts

@@ -702,5 +702,169 @@ export class PrintWriter {
   */
   format(l: Locale, format: string, ...args: any[]): PrintWriter;
 }
+/**
+ * Serializability of a class is enabled by the class implementing the
+ * java.io.Serializable interface.
+ *
+ * Warning: Deserialization of untrusted data is inherently dangerous
+ * and should be avoided. Untrusted data should be carefully validated according to the
+ * "Serialization and Deserialization" section of the
+ * {@extLink secure_coding_guidelines_javase Secure Coding Guidelines for Java SE}.
+ * {@extLink serialization_filter_guide Serialization Filtering} describes best
+ * practices for defensive use of serial filters.
+ * 
+ *
+ * Classes that do not implement this
+ * interface will not have any of their state serialized or
+ * deserialized.  All subtypes of a serializable class are themselves
+ * serializable.  The serialization interface has no methods or fields
+ * and serves only to identify the semantics of being serializable. 
+ *
+ * It is possible for subtypes of non-serializable classes to be serialized
+ * and deserialized. During serialization, no data will be written for the
+ * fields of non-serializable superclasses. During deserialization, the fields of non-serializable
+ * superclasses will be initialized using the no-arg constructor of the first (bottommost)
+ * non-serializable superclass. This constructor must be accessible to the subclass that is being
+ * deserialized. It is an error to declare a class Serializable if this is not
+ * the case; the error will be detected at runtime. A serializable subtype may
+ * assume responsibility for saving and restoring the state of a non-serializable
+ * supertype's public, protected, and (if accessible) package-access fields. See
+ * the 
+ * Java Object Serialization Specification, section 3.1, for
+ * a detailed specification of the deserialization process, including handling of
+ * serializable and non-serializable classes. 
+ *
+ * When traversing a graph, an object may be encountered that does not
+ * support the Serializable interface. In this case the
+ * NotSerializableException will be thrown and will identify the class
+ * of the non-serializable object. 
+ *
+ * Classes that require special handling during the serialization and
+ * deserialization process must implement special methods with these exact
+ * signatures:
+ *
+ *  * private void writeObject(java.io.ObjectOutputStream out)
+ *     throws IOException
+ * private void readObject(java.io.ObjectInputStream in)
+ *     throws IOException, ClassNotFoundException;
+ * private void readObjectNoData()
+ *     throws ObjectStreamException;
+ * 
+ *
+ * The writeObject method is responsible for writing the state of the
+ * object for its particular class so that the corresponding
+ * readObject method can restore it.  The default mechanism for saving
+ * the Object's fields can be invoked by calling
+ * out.defaultWriteObject. The method does not need to concern
+ * itself with the state belonging to its superclasses or subclasses.
+ * State is saved by writing the individual fields to the
+ * ObjectOutputStream using the writeObject method or by using the
+ * methods for primitive data types supported by DataOutput.
+ *
+ * The readObject method is responsible for reading from the stream and
+ * restoring the classes fields. It may call in.defaultReadObject to invoke
+ * the default mechanism for restoring the object's non-static and
+ * non-transient fields.  The defaultReadObject method uses information in
+ * the stream to assign the fields of the object saved in the stream with the
+ * correspondingly named fields in the current object.  This handles the case
+ * when the class has evolved to add new fields. The method does not need to
+ * concern itself with the state belonging to its superclasses or subclasses.
+ * State is restored by reading data from the ObjectInputStream for
+ * the individual fields and making assignments to the appropriate fields
+ * of the object. Reading primitive data types is supported by DataInput.
+ *
+ * The readObjectNoData method is responsible for initializing the state of
+ * the object for its particular class in the event that the serialization
+ * stream does not list the given class as a superclass of the object being
+ * deserialized.  This may occur in cases where the receiving party uses a
+ * different version of the deserialized instance's class than the sending
+ * party, and the receiver's version extends classes that are not extended by
+ * the sender's version.  This may also occur if the serialization stream has
+ * been tampered; hence, readObjectNoData is useful for initializing
+ * deserialized objects properly despite a "hostile" or incomplete source
+ * stream.
+ *
+ * Serializable classes that need to designate an alternative object to be
+ * used when writing an object to the stream should implement this
+ * special method with the exact signature:
+ *
+ *  * ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
+ * 
+ *
+ * This writeReplace method is invoked by serialization if the method
+ * exists and it would be accessible from a method defined within the
+ * class of the object being serialized. Thus, the method can have private,
+ * protected and package-private access. Subclass access to this method
+ * follows java accessibility rules. 
+ *
+ * Classes that need to designate a replacement when an instance of it
+ * is read from the stream should implement this special method with the
+ * exact signature.
+ *
+ *  * ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
+ * 
+ *
+ * This readResolve method follows the same invocation rules and
+ * accessibility rules as writeReplace.
+ *
+ * Enum types are all serializable and receive treatment defined by
+ * the 
+ * Java Object Serialization Specification during
+ * serialization and deserialization. Any declarations of the special
+ * handling methods discussed above are ignored for enum types.
+ *
+ * Record classes can implement `Serializable` and receive treatment defined
+ * by the 
+ * Java Object Serialization Specification, Section 1.13,
+ * "Serialization of Records". Any declarations of the special
+ * handling methods discussed above are ignored for record types.
+ *
+ * The serialization runtime associates with each serializable class a version
+ * number, called a serialVersionUID, which is used during deserialization to
+ * verify that the sender and receiver of a serialized object have loaded
+ * classes for that object that are compatible with respect to serialization.
+ * If the receiver has loaded a class for the object that has a different
+ * serialVersionUID than that of the corresponding sender's class, then
+ * deserialization will result in an {@link InvalidClassException}.  A
+ * serializable class can declare its own serialVersionUID explicitly by
+ * declaring a field named `"serialVersionUID"` that must be static,
+ * final, and of type `long`:
+ *
+ *  * ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
+ * 
+ *
+ * If a serializable class does not explicitly declare a serialVersionUID, then
+ * the serialization runtime will calculate a default serialVersionUID value
+ * for that class based on various aspects of the class, as described in the
+ * Java Object Serialization
+ * Specification. This specification defines the
+ * serialVersionUID of an enum type to be 0L. However, it is strongly
+ * recommended that all serializable classes other than enum types explicitly declare
+ * serialVersionUID values, since the default serialVersionUID computation is
+ * highly sensitive to class details that may vary depending on compiler
+ * implementations, and can thus result in unexpected
+ * `InvalidClassException`s during deserialization.  Therefore, to
+ * guarantee a consistent serialVersionUID value across different java compiler
+ * implementations, a serializable class must declare an explicit
+ * serialVersionUID value.  It is also strongly advised that explicit
+ * serialVersionUID declarations use the `private` modifier where
+ * possible, since such declarations apply only to the immediately declaring
+ * class--serialVersionUID fields are not useful as inherited members. Array
+ * classes cannot declare an explicit serialVersionUID, so they always have
+ * the default computed value, but the requirement for matching
+ * serialVersionUID values is waived for array classes.
+ *
+ * @see java.io.ObjectOutputStream
+ * @see java.io.ObjectInputStream
+ * @see java.io.ObjectOutput
+ * @see java.io.ObjectInput
+ * @see java.io.Externalizable
+ * @see 
+ *      Java Object Serialization Specification
+ * @since   1.1
+*/
+export class Serializable {
+
+}
 
 }

package/dist/java.lang.d.ts

@@ -0,0 +1,16 @@
+declare module 'java.lang' {
+/**
+ * Implementing this interface allows an object to be the target of the enhanced
+ * `for` statement (sometimes called the "for-each loop" statement).
+ *
+ * @param  the type of elements returned by the iterator
+ *
+ * @since 1.5
+ * @jls 14.14.2 The enhanced `for` statement
+*/
+export class Iterable<T> {
+  [Symbol.iterator](): globalThis.Iterator<T>;
+
+}
+
+}

package/dist/java.util.d.ts

@@ -1,5 +1,6 @@
 declare module 'java.util' {
-export class Collection<E> {
+import { Iterable } from 'java.lang';
+export class Collection<E> extends Iterable<E> {
   /**
    * Returns the number of elements in this collection.  If this collection
    * contains more than `Integer.MAX_VALUE` elements, returns

package/dist/javax.jcr.d.ts

@@ -725,6 +725,19 @@ export class NodeIterator {
    *          Nodes.
   */
   nextNode(): Node;
+  /**
+   * Returns the total number of of items available through this iterator. For
+   * example, for some node N, N.getNodes().getSize()
+   * returns the number of child nodes of N visible through the
+   * current Session. In some implementations precise information
+   * about the number of elements may not be available. In such cases this
+   * method must return -1. API clients will then be able to use
+   * RangeIterator.getNumberRemaining to get an estimate on the
+   * number of elements.
+   *
+   * @return a long
+  */
+  getSize(): number;
   /**
    * Returns `true` if the iteration has more elements.
    * (In other words, returns `true` if {@link #next} would

package/dist/javax.servlet.http.d.ts

@@ -978,6 +978,76 @@ export class HttpServletRequest {
  *
 */
 export class HttpServletResponse {
+  /**
+   * Encodes the specified URL by including the session ID,
+   * or, if encoding is not needed, returns the URL unchanged.
+   * The implementation of this method includes the logic to
+   * determine whether the session ID needs to be encoded in the URL.
+   * For example, if the browser supports cookies, or session
+   * tracking is turned off, URL encoding is unnecessary.
+   * 
+   * For robust session tracking, all URLs emitted by a servlet 
+   * should be run through this
+   * method.  Otherwise, URL rewriting cannot be used with browsers
+   * which do not support cookies.
+   *
+   * If the URL is relative, it is always relative to the current
+   * HttpServletRequest.
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed;
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeURL(url: string): string;
+  /**
+   * Encodes the specified URL for use in the
+   * sendRedirect method or, if encoding is not needed,
+   * returns the URL unchanged.  The implementation of this method
+   * includes the logic to determine whether the session ID
+   * needs to be encoded in the URL.  For example, if the browser supports
+   * cookies, or session tracking is turned off, URL encoding is
+   * unnecessary.  Because the rules for making this determination can
+   * differ from those used to decide whether to
+   * encode a normal link, this method is separated from the
+   * encodeURL method.
+   * 
+   * All URLs sent to the HttpServletResponse.sendRedirect
+   * method should be run through this method.  Otherwise, URL
+   * rewriting cannot be used with browsers which do not support
+   * cookies.
+   *
+   * If the URL is relative, it is always relative to the current
+   * HttpServletRequest.
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed;
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+   *
+   * @see #sendRedirect
+   * @see #encodeUrl
+  */
+  encodeRedirectURL(url: string): string;
+  /**
+   * @deprecated	As of version 2.1, use encodeURL(String url) instead
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed; 
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeUrl(url: string): string;
+  /**
+   * @deprecated	As of version 2.1, use 
+   *			encodeRedirectURL(String url) instead
+   *
+   * @param	url	the url to be encoded.
+   * @return		the encoded URL if encoding is needed; 
+   * 			the unchanged URL otherwise.
+   * @exception IllegalArgumentException if the url is not valid
+  */
+  encodeRedirectUrl(url: string): string;
   /**
    * Gets the current status code of this response.
    *

package/dist/nav/server/navBuilder/navBuilder.d.ts

@@ -1,6 +1,7 @@
 import type { JCRNodeWrapper } from "org.jahia.services.content";
 import type { RenderContext, Resource } from "org.jahia.services.render";
-interface MenuEntry {
+/** @deprecated */
+export interface MenuEntry {
     /** The HTML rendered HTML menu entry */
     render: string;
     /** The node object for the menu entry */
@@ -17,6 +18,8 @@ interface MenuEntry {
 /**
  * Build a navigation menu
  *
+ * @deprecated We recommend building your own navigation menu using the JCR API; it will be more
+ *   efficient and flexible.
  * @param maxDepth The maximum depth of the menu
  * @param base The base path of the menu
  * @param menuEntryView The view to use for each menu entry
@@ -25,5 +28,4 @@ interface MenuEntry {
  * @param currentResource The current resource
  * @returns An array of menu entries objects
  */
-export declare function buildNavMenu(maxDepth: number, base: string, menuEntryView: string, startLevelValue: number, renderContext: RenderContext, currentResource: Resource): MenuEntry[];
-export {};
+export declare function buildNavMenu(maxDepth: number, base: string, menuEntryView: string | undefined, startLevelValue: number, renderContext: RenderContext, currentResource: Resource): MenuEntry[];

package/dist/org.jahia.modules.javascript.modules.engine.js.server.d.ts

@@ -192,6 +192,7 @@ export class RenderHelper {
   transformToJsNode(node: JCRNodeWrapper, includeChildren: boolean, includeDescendants: boolean, includeAllTranslations: boolean): any;
   /**
    * Get the render parameters for the given resource
+   *
    * @param resource the resource for which to retrieve the render parameters
    * @return a Map<String,Object> containing the render parameters
   */
@@ -201,6 +202,7 @@ export class RenderHelper {
    * don't need encoding are those defined 'unreserved' in section 2.3 of
    * the 'URI generic syntax' RFC 2396. Not the entire path string is escaped,
    * but every individual part (i.e. the slashes are not escaped).
+   *
    * @param path the path to encode
    * @return a String containing the escaped path
    * @throws NullPointerException if path is null.
@@ -209,15 +211,17 @@ export class RenderHelper {
   /**
    * Find the first displayable node in the given node's hierarchy. A displayable node is a node that has a content
    * or page template associated with it.
-   * @param node the node at which to start the resolution
+   *
+   * @param node          the node at which to start the resolution
    * @param renderContext the current render context
-   * @param contextSite the site in which to resolve the template
+   * @param contextSite   the site in which to resolve the template
    * @return the first displayable {@link JCRNodeWrapper} found in the hierarchy
   */
-  findDisplayableNode(node: JCRNodeWrapper, renderContext: RenderContext, contextSite: JCRSiteNode): JCRNodeWrapper;
+  findDisplayableNode(node: JCRNodeWrapper, renderContext: RenderContext, contextSite: JCRSiteNode | null): JCRNodeWrapper;
   /**
    * Returns the node which corresponds to the bound component of the j:bindedComponent property in the specified node.
-   * @param node the node to get the bound component for
+   *
+   * @param node    the node to get the bound component for
    * @param context current render context
    * @return the bound {@link JCRNodeWrapper}
   */
@@ -227,62 +231,64 @@ export class RenderHelper {
   render(attr: any, renderContext: RenderContext, currentResource: Resource): string;
   /**
    * Render a tag that adds resources to the page. Resources might for example be CSS files, Javascript files or inline
-   * @param attr may contain the following:
-   *             
-   *              insert (boolean) : If true, the resource will be inserted into the document. Typically used
-   *             for on-demand loading of resources. 
-   *              async (boolean) : If true, the resource will be loaded asynchronously. For scripts, this means
-   *             the script
-   *             will be executed as soon as it's available, without blocking the rest of the page. 
-   *              defer (boolean) : If true, the resource will be deferred, i.e., loaded after the document
-   *             has been parsed.
-   *             For scripts, this means the script will not be executed until after the page has loaded. 
-   *              type (string) : The type of the resource. This could be 'javascript' for .js files, 'css' for
-   *             .css files, etc.
-   *             The type will be used to resolve the directory in the module where the resources are located. For example
-   *             for the 'css' type it will look for the resources in the css directory of the module. 
-   *              resources (string) : The path to the resource file, relative to the module. It is also allowed to
-   *             specify multiple resources by separating them with commas. It is also allowed to use absolute URLs to
-   *             include remote resources. 
-   *              inlineResource (string) : Inline HTML that markup will be considered as a resource. 
-   *              title (string) : The title of the resource. This is typically not used for scripts or stylesheets,
-   *             but may be used for other types of resources. 
-   *              key (string) : A unique key for the resource. This could be used to prevent duplicate resources
-   *             from being added to the document. 
-   *              targetTag (string): The HTML tag where the resource should be added. This could be 'head' for
-   *             resources that should be added to the <head> tag, 'body' for resources that should be added to
-   *             the <body> tag, etc.
-   *              rel (string) : The relationship of the resource to the document. This is typically 'stylesheet'
-   *             for CSS files. 
-   *              media (string) : The media for which the resource is intended. This is typically used for CSS
-   *             files, with values like 'screen', 'print', etc. 
-   *              condition (string) : A condition that must be met for the resource to be loaded. This could be
-   *             used for conditional comments in IE, for example.
-   *             
+   *
+   * @param attr          may contain the following:
+   *                      
+   *                       insert (boolean) : If true, the resource will be inserted into the document. Typically used
+   *                      for on-demand loading of resources. 
+   *                       async (boolean) : If true, the resource will be loaded asynchronously. For scripts, this means
+   *                      the script
+   *                      will be executed as soon as it's available, without blocking the rest of the page. 
+   *                       defer (boolean) : If true, the resource will be deferred, i.e., loaded after the document
+   *                      has been parsed.
+   *                      For scripts, this means the script will not be executed until after the page has loaded. 
+   *                       type (string) : The type of the resource. This could be 'javascript' for .js files, 'css' for
+   *                      .css files, etc.
+   *                      The type will be used to resolve the directory in the module where the resources are located. For example
+   *                      for the 'css' type it will look for the resources in the css directory of the module. 
+   *                       resources (string) : The path to the resource file, relative to the module. It is also allowed to
+   *                      specify multiple resources by separating them with commas. It is also allowed to use absolute URLs to
+   *                      include remote resources. 
+   *                       inlineResource (string) : Inline HTML that markup will be considered as a resource. 
+   *                       title (string) : The title of the resource. This is typically not used for scripts or stylesheets,
+   *                      but may be used for other types of resources. 
+   *                       key (string) : A unique key for the resource. This could be used to prevent duplicate resources
+   *                      from being added to the document. 
+   *                       targetTag (string): The HTML tag where the resource should be added. This could be 'head' for
+   *                      resources that should be added to the <head> tag, 'body' for resources that should be added to
+   *                      the <body> tag, etc.
+   *                       rel (string) : The relationship of the resource to the document. This is typically 'stylesheet'
+   *                      for CSS files. 
+   *                       media (string) : The media for which the resource is intended. This is typically used for CSS
+   *                      files, with values like 'screen', 'print', etc. 
+   *                       condition (string) : A condition that must be met for the resource to be loaded. This could be
+   *                      used for conditional comments in IE, for example.
+   *                      
    * @param renderContext the current rendering context
    * @return a String containing the rendered HTML tags for the provided resources.
-   * @throws IllegalAccessException if the underlying tag cannot be accessed
+   * @throws IllegalAccessException    if the underlying tag cannot be accessed
    * @throws InvocationTargetException if the underlying tag cannot be invoked
-   * @throws JspException if the underlying tag throws a JSP exception
-   * @throws IOException if the underlying tag throws an IO exception
+   * @throws JspException              if the underlying tag throws a JSP exception
+   * @throws IOException               if the underlying tag throws an IO exception
   */
   addResources(attr: any, renderContext: RenderContext): string;
   /**
    * Add a cache dependency to the current resource. This will be used to flush the current resource when the
    * dependencies are modified.
-   * @param attr may be the following:
-   *             
-   *              node (JCRNodeWrapper) : The node to add as a dependency. 
-   *              uuid (String) : The UUID of the node to add as a dependency. 
-   *              path (String) : The path of the node to add as a dependency. 
-   *              flushOnPathMatchingRegexp (String) : A regular expression that will be used to flush the cache
-   *             when the path of the modified nodes matches the regular expression. 
-   *             
+   *
+   * @param attr          may be the following:
+   *                      
+   *                       node (JCRNodeWrapper) : The node to add as a dependency. 
+   *                       uuid (String) : The UUID of the node to add as a dependency. 
+   *                       path (String) : The path of the node to add as a dependency. 
+   *                       flushOnPathMatchingRegexp (String) : A regular expression that will be used to flush the cache
+   *                      when the path of the modified nodes matches the regular expression. 
+   *                      
    * @param renderContext the current rendering context
-   * @throws IllegalAccessException if the underlying tag cannot be accessed
+   * @throws IllegalAccessException    if the underlying tag cannot be accessed
    * @throws InvocationTargetException if the underlying tag cannot be invoked
-   * @throws JspException if the underlying tag throws a JSP exception
-   * @throws IOException if the underlying tag throws an IO exception
+   * @throws JspException              if the underlying tag throws a JSP exception
+   * @throws IOException               if the underlying tag throws an IO exception
   */
   addCacheDependency(attr: any, renderContext: RenderContext): void;
   renderAbsoluteArea(attr: any, renderContext: RenderContext): string;