@sitevision/api 1.0.19 → 1.1.0-alpha.1

package/hidden/senselogic/sitevision/api/script/app/RestAppInvoker/index.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Script utility for server-side invoke of a local RESTApp.
+ *
+ * <p>
+ *    This is a local, server-side, inbound utility to invoke a specific
+ *    <a href="https://developer.sitevision.se/restapps" target="_blank">RESTApp</a>
+ *    of the local site without any outgoing http connections.
+ *    This utility can be used regardless of the RESTApp allows requests or not!
+ *    Verb/method restrictions (GET/POST/PUT/DELETE) specified for the RESTApp will be respected.
+ * </p>
+ *
+ * <div id="options">
+ *    <h3>RESTApp invocation</h3>
+ *    <p>
+ *       This utility has methods to server-side invoke a specific RESTApp that resides on the same site as this code is executed.
+ *       Each method requires that a <em>route</em> is specified. Each method also allows for <em>options</em> to be passed to the RESTApp
+ *       so it can do its job properly. Each method returns an object with the result of the RESTApp invocation.
+ *    </p>
+ *    <h4>Options</h4>
+ *    <ul>
+ *       <li>
+ *          <strong>headers</strong> <em>(key/value object)</em> [optional]
+ *          - request headers to pass to the invoking RESTApp.
+ *       </li>
+ *       <li>
+ *          <strong><em>&lt;name&gt;</em></strong> <em>(key/value object)</em> [optional, RESTApp dependant]
+ *          - named parameters/data/files to pass to the invoking RESTApp.
+ *       </li>
+ *    </ul>
+ *    <h4>Result</h4>
+ *    <ul>
+ *       <li>
+ *          <strong>statusCode</strong> <em>(integer)</em>
+ *          - the http status code.
+ *       </li>
+ *       <li>
+ *          <strong>statusMessage</strong> <em>(string)</em>
+ *          - the status code message or error message.
+ *       </li>
+ *       <li>
+ *          <strong>headers</strong> <em>(key/value object)</em> [optional, RESTApp dependant]
+ *          - potential response headers set by the invoked RESTApp.
+ *       </li>
+ *       <li>
+ *          <strong>body</strong> - [optional, RESTApp dependant]
+ *          - potential result set by the invoked RESTApp:
+ *          <ul>
+ *             <li>
+ *                {@link javax.jcr.Node} (of type sv:file, sv:image or sv:temporaryFileNode) if the RESTApp executes
+ *                <code>
+ *                   <a href="https://developer.sitevision.se/docs/rest-api/restapps/index.js#h-ressendFilefile" target="_blank">res.sendFile</a>
+ *                </code>
+ *             </li>
+ *             <li>
+ *                <code>object</code> if the RESTApp executes
+ *                <code>
+ *                   <a href="https://developer.sitevision.se/docs/rest-api/restapps/index.js#h-resjsonresponse" target="_blank">res.json</a>
+ *                </code>
+ *             </li>
+ *             <li>
+ *                <code>string</code> if the RESTApp executes
+ *                <code>
+ *                   <a href="https://developer.sitevision.se/docs/rest-api/restapps/index.js#h-ressendresponse" target="_blank">res.send</a>
+ *                </code>
+ *             </li>
+ *          </ul>
+ *       </li>
+ *    </ul>
+ * </div>
+ *
+ * <h3>Basic GET example</h3>
+ * <p>
+ *    Below is an example of how to use the RestAppInvoker utility to execute a GET on the items route of a RESTApp.
+ * </p><pre><code>   var restAppInvokerFactory = require('RestAppInvokerFactory'),
+ *       restApp = restAppInvokerFactory.fromPath('/rest-api/my-rest-app'),
+ *       result;
+ *
+ *    if (restApp) {
+ *       result = restApp.get('/items', {count:5});
+ *       if (result.statusCode === 200) {
+ *          <em>// Handle valid result ...</em>
+ *          result.body ...
+ *       } else {
+ *          <em>// Handle other/error result ...</em>
+ *       }
+ *    }</code></pre>
+ *
+ * <h3>Basic POST example</h3>
+ * <p>
+ *    Below is an example of how to use the RestAppInvoker utility to execute a POST on the addfile route of a RESTApp.
+ * </p><pre><code>   var restAppInvokerFactory = require('RestAppInvokerFactory'),
+ *       restApp = restAppInvokerFactory.fromPath('/rest-api/my-rest-app'),
+ *       fileNode,
+ *       options,
+ *       result;
+ *
+ *    if (restApp) {
+ *       fileNode = ... <em>// Get the JCR file Node (sv:file, sv:image) to pass to the RESTApp</em>
+ *
+ *       options = {
+ *          headers: {
+ *             'X-custom-header': 'Custom value'
+ *          },
+ *          spreadsheet: fileNode,
+ *          sendMail: true,
+ *          customerId: 'abc123'
+ *       };
+ *
+ *       result = restApp.post('/addfile', options);
+ *       if (result.statusCode === 200) {
+ *          <em>// Handle valid result ...</em>
+ *          result.body ...
+ *       } else {
+ *          <em>// Handle other/error result ...</em>
+ *       }
+ *    }</code></pre>
+ *
+ * <p>
+ *    <strong>REST siblings note!</strong>
+ * </p>
+ * <ul>
+ *    <li>
+ *       Server-side invoke of the <em>local Sitevision REST API</em> should typically be handled via
+ *       {@link senselogic.sitevision.api.script.RestApi}.
+ *    </li>
+ *    <li>
+ *       Invoking <em>external REST API:s</em> should typically be handled via
+ *       {@link senselogic.sitevision.api.script.Requester}.
+ *    </li>
+ * </ul>
+ *
+ * <p>
+ *    An instance of the Sitevision class implementing this interface can be obtained via a method in
+ *    {@link RestAppInvokerFactory}.
+ * </p>Executes GET for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>get</em> typically indicates a <em>read</em> of something.
+ * </p>Executes GET with options for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>get</em> typically indicates a <em>read</em> of something.
+ * </p>Executes POST for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>post</em> typically indicates the <em>creation</em> of something.
+ * </p>Executes POST with options for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>post</em> typically indicates the <em>creation</em> of something.
+ * </p>Executes PUT for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>put</em> typically indicates an <em>update</em> of something.
+ * </p>Executes PUT with options for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>put</em> typically indicates an <em>update</em> of something.
+ * </p>Executes DELETE for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>delete</em> typically indicates a <em>removal</em> of something.
+ * </p>Executes DELETE with options for a route of the RESTApp.
+ *
+ * <p>
+ *    <em>REST hint!</em> A <em>delete</em> typically indicates a <em>removal</em> of something.
+ * </p>
+ * @param <O> script object
+ * @author Magnus Lövgren
+ * @since Sitevision 7
+ * @see senselogic.sitevision.api.script.RestApi
+ * @see senselogic.sitevision.api.script.Requester
+ */
+interface RestAppInvoker {
+  /**
+   * Executes GET for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>get</em> typically indicates a <em>read</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   * @see #get(String, Object)
+   */
+  get(aRoute: string): unknown;
+
+  /**
+   * Executes GET with options for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>get</em> typically indicates a <em>read</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @param aOptions a options
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   */
+  get(aRoute: string, aOptions: unknown): unknown;
+
+  /**
+   * Executes POST for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>post</em> typically indicates the <em>creation</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   * @see #post(String, Object)
+   */
+  post(aRoute: string): unknown;
+
+  /**
+   * Executes POST with options for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>post</em> typically indicates the <em>creation</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @param aOptions a options
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   */
+  post(aRoute: string, aOptions: unknown): unknown;
+
+  /**
+   * Executes PUT for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>put</em> typically indicates an <em>update</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   * @see #put(String, Object)
+   */
+  put(aRoute: string): unknown;
+
+  /**
+   * Executes PUT with options for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>put</em> typically indicates an <em>update</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @param aOptions a options
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   */
+  put(aRoute: string, aOptions: unknown): unknown;
+
+  /**
+   * Executes DELETE for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>delete</em> typically indicates a <em>removal</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   * @see #delete(String, Object)
+   */
+  delete(aRoute: string): unknown;
+
+  /**
+   * Executes DELETE with options for a route of the RESTApp.
+   *
+   * <p>
+   *    <em>REST hint!</em> A <em>delete</em> typically indicates a <em>removal</em> of something.
+   * </p>
+   * @param aRoute a route
+   * @param aOptions a options
+   * @return a script object representing the response (properties: headers, statusCode, statusMessage, body)
+   */
+  delete(aRoute: string, aOptions: unknown): unknown;
+}
+
+export default RestAppInvoker;

package/hidden/senselogic/sitevision/api/script/factory/TypedArgument/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * This interface is a representation of a constructor argument (it's value and type) that can be used to
+ * create Java object instances via {@link InstanceCreatorUtil}.
+ *
+ * <p>
+ *    An instance of the Sitevision class implementing this interface can be obtained via any of these methods:
+ * </p>
+ * <ul>
+ *    <li>{@link InstanceCreatorUtil#getBooleanArgument(boolean)}</li>
+ *    <li>{@link InstanceCreatorUtil#getByteArgument(byte)}</li>
+ *    <li>{@link InstanceCreatorUtil#getCharArgument(char)}</li>
+ *    <li>{@link InstanceCreatorUtil#getCustomArgument(String, Object)}</li>
+ *    <li>{@link InstanceCreatorUtil#getDoubleArgument(double)}</li>
+ *    <li>{@link InstanceCreatorUtil#getEnumArgument(String, Object)}</li>
+ *    <li>{@link InstanceCreatorUtil#getFloatArgument(float)}</li>
+ *    <li>{@link InstanceCreatorUtil#getIntArgument(int)}</li>
+ *    <li>{@link InstanceCreatorUtil#getLongArgument(long)}</li>
+ *    <li>{@link InstanceCreatorUtil#getNullArgument(String)}</li>
+ *    <li>{@link InstanceCreatorUtil#getObjectArgument(Object)}</li>
+ *    <li>{@link InstanceCreatorUtil#getShortArgument(short)}</li>
+ * </ul>
+ *
+ * <p>
+ *    See {@link InstanceCreatorUtil} for how to obtain an instance of the <code>InstanceCreatorUtil</code> interface.
+ * </p>Gets the argument class.Gets the argument value.
+ * @author Magnus Lövgren
+ * @since Sitevision 3.1
+ */
+interface TypedArgument {
+  /**
+   * Gets the argument class.
+   * @return the class of the argument
+   */
+  getType(): unknown;
+
+  /**
+   * Gets the argument value.
+   * @return the value of the argument
+   */
+  getValue(): unknown;
+}
+
+export default TypedArgument;

package/hidden/senselogic/sitevision/api/script/proxy/ExceptionSuppressingCollection/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Decorates the iterator of a collection with a {@link ExceptionSuppressingIterator} to ensure exceptions are suppressed for all
+ * iterator invocations.
+ *
+ * <p>
+ *    The sole purpose of the <code>ExceptionSuppressingCollection</code> is to provide easy access to a decorated iterator
+ *    (i.e. an {@link ExceptionSuppressingIterator}). You should <em>not</em> create a collection of exception suppressing proxys
+ *    (i.e. <code>Collection&lt;ExceptionSuppressingProxy&gt;</code>) yourself. You should use <code>ExceptionSuppressingCollection</code>
+ *    with your "regular" collection since the actual proxying is done by the iterator itself.
+ * </p>
+ * <p>
+ *    Note that the <code>next</code> method of the interator returns an instance of a <em>Dynamic proxy</em> so not all methods can be invoked
+ *    directly on the returned object. To invoke a method that is not proxied (i.e. a method not declared in an interface the object implements),
+ *    you must extract the "real" object from the proxy and use that reference when invoking the method. See {@link ExceptionSuppressingIterator}
+ *    for more information about the iterator and {@link ExceptionSuppressingProxy} for more information about dynamic proxies and how to extract
+ *    "real" object.
+ * </p>
+ *
+ * <p>
+ *    <strong>Important note! </strong>This interface is intended to be used <em>only</em> in contexts where exceptions when iterating a
+ *    collection will cause <em>serious</em> trouble if they arise and the context doesn't provide proper exception handling
+ *    (e.g. when rendering a Velocity template). Suppressing exceptions is generally a bad idea and using this decorator will affect performance.
+ *    Hence, this interface should only be used where the upsides with suppressing exceptions outweighs the downsides.
+ *    This interface should be used only as a temporary patch/solution until the "real" problem causing the exception has been solved.
+ * </p>
+ *
+ * <p>
+ *    An instance of the Sitevision class implementing this interface can be obtained via
+ *    {@link senselogic.sitevision.api.Utils#getExceptionSuppressingCollection(java.util.Collection)}.
+ *    See {@link senselogic.sitevision.api.Utils} for how to obtain an instance of the <code>Utils</code> interface.
+ * </p>
+ *
+ * <p>
+ * ----------------------------------------------------------------------------------------------------
+ * </p>
+ *
+ * <p>
+ * <strong>Example of how <code>ExceptionSuppressingCollection</code> could be used in Velocity:</strong>
+ * </p>
+ *
+ * <p>Case description:</p>
+ * <p>
+ *    <em>You have a Velocity template where you iterate a collection. Sometimes a certain method throws an exception.
+ *    The rendered output of the template gets corrupt whenever an exception is thrown and you have not yet tracked down the root
+ *    cause of the exception. Until the root cause is found and the problem is fixed, you need a temporary solution that ignores
+ *    exceptions to keep template output acceptable. Since the method is declared in an interface and implemented in the instance
+ *    you're invoking, you're in sheer luck. You can decorate your collection with a <code>ExceptionSuppressingCollection</code>
+ *    to get a decorated iterator. When interating, all returned elements are proxied by an <code>ExceptionSuppressingProxy</code>.
+ *    Invoking the method through the proxy will suppress exceptions and you can diminish the output problems.
+ *    Note that you should invoke the real object for all non-problematic methods and methods that can't be proxied
+ *    (i.e. methods not declared in an interface). To get a reference to the real object,
+ *    use {@link ExceptionSuppressingProxy#getProxiedObject()}.</em>
+ * </p>
+ * <p>
+ *    This is what the code looks like before your temporary fix:
+ * </p>
+ * <pre><code>
+ *    #foreach ($item in $myCollection)
+ *       &lt;p&gt;
+ *          $item.thisNeverThrowsExceptions()
+ *          $item.thisMethodSometimesThrowsExceptions()
+ *       &lt;/p&gt;
+ *    #end
+ * </code></pre>
+ * <p>
+ *    This is how you could use an <code>ExceptionSuppressingCollection</code> to apply a temporary fix:
+ * </p>
+ * <pre><code>
+ *    <em>## Decorate collection</em>
+ *    #set ($decoratedCollection = $sitevisionUtils.getExceptionSuppressingCollection($myCollection))
+ *
+ *    #foreach ($item in $decoratedCollection)
+ *       &lt;p&gt;
+ *          <em>## Get the real object and invoke non-problematic method as usual</em>
+ *          #set ($realObject = $item.getProxiedObject())
+ *
+ *          $realObject.thisNeverThrowsExceptions()
+ *          $!item.thisMethodSometimesThrowsExceptions() <em>## Executed through a proxy, might return null</em>
+ *      &lt;/p&gt;
+ *   #end
+ *   &lt;/p&gt;
+ * </code></pre>Returns an exception suppressing iterator that ensures no exceptions will be thrown during iteration.
+ * @author Magnus Lövgren
+ * @since Sitevision 2.6.1_09
+ */
+interface ExceptionSuppressingCollection {
+  /**
+   * Returns an exception suppressing iterator that ensures no exceptions will be thrown during iteration.
+   * @return a {@link ExceptionSuppressingIterator} that suppresses exceptions and returns proxied items
+   */
+  iterator(): unknown;
+}
+
+export default ExceptionSuppressingCollection;

package/hidden/senselogic/sitevision/api/script/proxy/ExceptionSuppressingIterator/index.d.ts

@@ -0,0 +1,117 @@
+import ExceptionSuppressingProxy from "../ExceptionSuppressingProxy";
+
+/**
+ * Decorates an iterator with exception suppressing behaviour and returns {@link ExceptionSuppressingProxy}s in order to ensure that no
+ * invocation will throw an exception.
+ *
+ * <p>
+ *    This iterator is of type <code>ExceptionSuppressingProxy</code> that is an implementation of a <em>Dynamic proxy</em> so not all
+ *    methods can be directly invoked on objects retrieved by the <code>next</code> method. See {@link ExceptionSuppressingCollection}
+ *    for an example of how this iterator can be used easily from Velocity and how to invoke methods not declared in an interface.
+ *    See {@link ExceptionSuppressingProxy} for more information about dynamic proxies.
+ * </p>
+ * <p>
+ * <strong>Important note! </strong>This interface is intended to be used <em>only</em> in contexts where exceptions thrown during iteration will
+ * cause <em>serious</em> trouble if they arise and the context doesn't provide proper exception handling (e.g. when executing a Velocity template).
+ * Suppressing exceptions is generally a bad idea and using this iterator will affect performance.
+ * Hence, this interface should only be used where the upsides with suppressing exceptions far outweighs the downsides.
+ * This interface should be used only as a temporary patch/solution until the "real" problem causing the exception has been solved.
+ * </p>
+ *
+ * <p>
+ *    An instance of the Sitevision class implementing this interface can be obtained directly via
+ *    {@link senselogic.sitevision.api.Utils#getExceptionSuppressingIterator(java.util.Iterator)}
+ *    or indirectly via {@link senselogic.sitevision.api.Utils#getExceptionSuppressingCollection(java.util.Collection)}.
+ *    You would typically use the latter if you should iterate a collection with the Velocity #foreach loop.
+ *    See {@link senselogic.sitevision.api.Utils} for how to obtain an instance of the <code>Utils</code> interface.
+ * </p>Returns <code>true</code> if decorated iterator has more elements. (In other words, returns <code>true</code>
+ * if <code>next</code> would return an element rather than throwing an exception.)
+ *
+ * <p>
+ * This method will never throw an exception
+ * </p>Returns a proxy for the next element of the decorated iterator. Calling this method repeatedly until the {@link #hasNext()} method
+ * returns <code>false</code> will return each element in the underlying collection exactly once.
+ *
+ * <p>
+ *    <strong>Note!</strong> The returned element will be embedded in an <code>ExceptionSuppressingProxy</code> that will be reused for
+ *    <em>all</em> next() invocations on this iterator. In other words, the proxied item of the returned element will change,
+ *    but never the returned element itself. This implies that you shouldn't keep references to an item retrieved from a next()
+ *    invocation during iteration. If you do, don't be surprised if the element contains something else than it did when you set the reference...
+ * </p>
+ *
+ * <p>
+ * This method will never throw an exception.
+ * </p>
+ * <p>
+ *    <strong>Note! </strong>Be aware of <code>null</code> items since they're never proxied. If the underlying collection contains a
+ *    <code>null</code> item, this iterator will just return <code>null</code>, not a proxy. In other words: even though this method
+ *    won't throw any exceptions, invoking a method on the returned object might throw a <code>NullPointerException</code>.
+ * </p>Tries to remove from the underlying collection the last element returned by decorated iterator (optional operation).
+ * This method can be called only once per call to <code>next</code>. The behavior of an iterator is unspecified if
+ * the underlying collection is modified while the iteration is in progress in any way other than by calling this method.
+ *
+ * <p>
+ * This method will never throw an exception.
+ * </p>
+ * <p>
+ * <strong>Note!</strong> Since exceptions are suppressed, you can never tell if the remove operation actually succeeded
+ * or if the underlying collection doesn't support removal (i.e. <code>UnsupportedOperationException</code> thrown by the
+ * decorated iterator is catched by this iterator).
+ * </p>
+ * @author Magnus Lövgren
+ * @since Sitevision 2.6.1_09
+ */
+interface ExceptionSuppressingIterator {
+  /**
+   * Returns <code>true</code> if decorated iterator has more elements. (In other words, returns <code>true</code>
+   * if <code>next</code> would return an element rather than throwing an exception.)
+   *
+   * <p>
+   * This method will never throw an exception
+   * </p>
+   * @return <code>true</code> if the decorated iterator has more elements, <code>false</code> if not or if an exception is thrown by the decorated iterator
+   */
+  hasNext(): boolean;
+
+  /**
+   * Returns a proxy for the next element of the decorated iterator. Calling this method repeatedly until the {@link #hasNext()} method
+   * returns <code>false</code> will return each element in the underlying collection exactly once.
+   *
+   * <p>
+   *    <strong>Note!</strong> The returned element will be embedded in an <code>ExceptionSuppressingProxy</code> that will be reused for
+   *    <em>all</em> next() invocations on this iterator. In other words, the proxied item of the returned element will change,
+   *    but never the returned element itself. This implies that you shouldn't keep references to an item retrieved from a next()
+   *    invocation during iteration. If you do, don't be surprised if the element contains something else than it did when you set the reference...
+   * </p>
+   *
+   * <p>
+   * This method will never throw an exception.
+   * </p>
+   * <p>
+   *    <strong>Note! </strong>Be aware of <code>null</code> items since they're never proxied. If the underlying collection contains a
+   *    <code>null</code> item, this iterator will just return <code>null</code>, not a proxy. In other words: even though this method
+   *    won't throw any exceptions, invoking a method on the returned object might throw a <code>NullPointerException</code>.
+   * </p>
+   * @return the next element, or <code>null</code> if an exception is thrown.
+   */
+  next(): ExceptionSuppressingProxy;
+
+  /**
+ * Tries to remove from the underlying collection the last element returned by decorated iterator (optional operation).
+ * This method can be called only once per call to <code>next</code>. The behavior of an iterator is unspecified if
+ * the underlying collection is modified while the iteration is in progress in any way other than by calling this method.
+ *
+ * <p>
+ * This method will never throw an exception.
+ * </p>
+ * <p>
+ * <strong>Note!</strong> Since exceptions are suppressed, you can never tell if the remove operation actually succeeded
+ * or if the underlying collection doesn't support removal (i.e. <code>UnsupportedOperationException</code> thrown by the
+ * decorated iterator is catched by this iterator).
+ * </p>
+  
+    */
+  remove(): void;
+}
+
+export default ExceptionSuppressingIterator;

package/hidden/senselogic/sitevision/api/script/proxy/ExceptionSuppressingProxy/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Proxies an object and delegates all interface method invocations to the proxied object in order to ensure that no invocation
+ * will throw an exception.
+ *
+ * <p>
+ *    This interface is an exception suppressing implementation of a so called
+ *    <em><a href="http://docs.oracle.com/javase/8/docs/technotes/guides/reflection/proxy.html">Dynamic proxy</a></em>.
+ *    This means it will proxy all methods of an object that are declared in an interface implemented by the object.
+ *    If a method invocation through this proxy throws an <code>Exception</code>, it will be catched and the default value will be returned
+ *    (e.g. <code>null</code>, <code>0</code>, <code>false</code> etc).
+ * </p>
+ *
+ * <p>
+ *    <strong>Important note! </strong>This interface is intended to be used <em>only</em> in contexts where exceptions will cause <em>serious</em>
+ *    trouble if they arise and the context doesn't provide proper exception handling (e.g. when executing a Velocity template).
+ *    Suppressing exceptions is generally a <em>really</em> bad idea and using this proxy will affect performance.
+ *    Hence, this interface should only be used where the upsides with suppressing exceptions far outweighs the downsides.
+ *    This interface should be used only as a temporary patch/solution until the "real" problem causing the exception has been solved.
+ * </p>
+ *
+ * <p>
+ *    The state of an ExceptionSuppressingProxy is available at all times and updated for each method invocation
+ *    (except for invocations of methods declared in this interface).
+ *    If last method invocation resulted in a thrown exception the proxy status will be {@link #EXCEPTION_THROWN_STATUS}
+ *    and the exception will be available via {@link #getCurrentException()}.
+ * </p>
+ *
+ * <p>
+ *    An instance of the Sitevision class implementing this interface can be obtained via
+ *    {@link senselogic.sitevision.api.Utils#getExceptionSuppressingProxy(Object)}.
+ *    See {@link senselogic.sitevision.api.Utils} for how to obtain an instance of the <code>Utils</code> interface.
+ * </p>
+ *
+ * <p>
+ * ----------------------------------------------------------------------------------------------------
+ * </p>
+ *
+ * <p>
+ * <strong>Example of how <code>ExceptionSuppressingProxy</code> could be used in Velocity:</strong>
+ * </p>
+ *
+ * <p>Case description:</p>
+ * <p>
+ *    <em>You have a Velocity template where a certain method invocation sometimes throws an exception.
+ *    The rendered output of the template gets corrupt whenever an exception is thrown and you have not yet tracked down the root cause
+ *    of the exception. Until the root cause is found and the problem is fixed, you need a temporary solution that ignores exceptions
+ *    to keep template output acceptable. Since the method is declared in an interface and implemented in the instance you're invoking,
+ *    you're in sheer luck. You can use an <code>ExceptionSuppressingProxy</code> to suppress exceptions in order to diminish output
+ *    problems.</em><p>This is what the code looks like before your temporary fix:
+ * </p>
+ * <pre><code>
+ *    &lt;p&gt;
+ *       $myObject.thisNeverThrowsExceptions()
+ *       $myObject.thisMethodSometimesThrowsExceptions() <em>## This method is declared in an interface, hence can be proxied</em>
+ *    &lt;/p&gt;
+ * </code></pre>
+ * This is how you could use an <code>ExceptionSuppressingProxy</code> to apply a temporary fix:<pre><code>
+ *    &lt;p&gt;
+ *       $myObject.thisNeverThrowsExceptions()
+ *
+ *       <em>## Get an ExceptionSuppressingProxy instance for myObject</em>
+ *       #set ($proxy = $sitevisionUtils.getExceptionSuppressingProxy($myObject))
+ *
+ *       $!proxy.thisMethodSometimesThrowsExceptions() <em>## Method invoked through a proxy, might return null</em>
+ *    &lt;/p&gt;
+ * </code></pre>Returns current statusReturns the exception that was thrown during last method invocation of the proxied object.Returns the proxied objectThe status indicating that this proxy has no object set, nothing to proxy.The status indicating that last method invocation did not throw an exception.The status indicating that last method invocation did throw an exception
+ * @author Magnus Lövgren
+ * @since Sitevision 2.6.1_09
+ */
+interface ExceptionSuppressingProxy {
+  /**
+   * Returns current status
+   * @return {@link #NO_OBJECT_PROXIED_STATUS} or {@link #NO_EXCEPTION_THROWN_STATUS} or {@link #EXCEPTION_THROWN_STATUS}
+   */
+  getCurrentStatus(): number;
+
+  /**
+   * Returns the exception that was thrown during last method invocation of the proxied object.
+   * @return the exception thrown during last method invocation, or <code>null</code> if no exeption was thrown
+   */
+  getCurrentException(): unknown;
+
+  /**
+   * Returns the proxied object
+   * @return the object that is proxied by an instance of this interface, or <code>null</code> if no proxied object is set
+   */
+  getProxiedObject(): unknown;
+}
+
+export default ExceptionSuppressingProxy;