thrau / wicket-js

wicket-js makes it easy to write and handle custom JavaScript and jQuery from within Wicket Components and Behaviors.

Wicket JavaScript and jQuery

 

wicket-js makes it easy to write and handle custom JavaScript and jQuery from within Wicket Components and Behaviors. It helps to separate Wicket Ajax Behavior listeners from actual client-side UI functionality, while maintaining the coupling towards Wicket Components.

It provides a (rudimentary) fluent interface that allows you to build JavaScript and jQuery expressions in Java.

Example

With wicket-js you can bind arbitrary JavaScript code to Wicket Components in a clean way. It provides basic syntax elements for typesafe script creation.

component.add(new JsBehavior() {
    @Override
    protected IJavaScript domReadyJs() {
        return new JsCall("alert", "loaded component with markup-id " + id());
    }
});

The API also provides a convenient way of writing jQuery expressions and bind client-side jQuery event behavior to components. This allows for separation of the Wicket AJAX listening mechanisms and the true client-side JavaScript functionality while keeping the JavaScript in the actuall Component definitions.

component.add(new JQueryEventBehavior("mouseenter mouseleave") {
    @Override
    protected IJavaScript callback() {
        return new JsStatements(
                $(this).toggleClass("entered"),
                $(this).trigger("toggled")
        );
    }
});

With jQuery's trigger and Wickets AjaxEventBehavior you can wire client-side JavaScript behavior with Wicket AJAX event handling in a clean way while keeping them separate.

component.add(new AjaxEventBehavior("toggled") {
    @Override
    protected void onEvent(AjaxRequestTarget target) {
        System.out.println("selection has changed!");
    }
});

Dependencies

• wicket-core 6.11.0
• jackson-databind [2.0,)

Notice

wicket-js is in alpha phase and subject to rapid development and change

wicket-js's Issues

JsObject builder to build Map type objects

To avoid

Map<Object, Object> map = new HashMap<>();
map.put(k, v);
JsObject obj = JsLiteral.of(map);

Something like the BSON builder would be nice

new JsObject().put(k, v)

Pull up JQuery API into an Interface

the JQuery class could be interfaced with IJQuery, where all the documentation goes.

Use org.rauschig/oss-parent as pom parent

Make JSON serialization consider IModel

Like we did for #10 , only for IModel instances.

Compile against Wicket 6.0.0

Which will broaden the range of the bundle dependencies.

JsLink feature

Like Wickets AjaxLink only that it doesn't execute an ajax call.

Refactor PropertyBindingOptions to extend from Options

PropertyBindingOptions can be generified and use Options as base class.

JsBehavior for Widgets

jQuery widgets are usually initialized like this

$('#component').myWidget({
    "property1": "value1",
    "property2": 2,
});

this idiom could be encapsulated in a Behavior extension

Wicket integration tests

Write integration tests using the wicket application test tools

Complete the JQuery API

Completely model the current jQuery API version

Support for logical expressions

Implement logical expressions (with junctions and negations)

http://www-archive.mozilla.org/js/language/grammar14.html#N-ConditionalExpression

Integration for AjaxRequestAttributes

The easiest way i found to add "dynamic" (evaluated expressions) parameters to an ajax request that can be retrieved at the target is the following:

@Override
protected void updateAjaxAttributes(AjaxRequestAttributes attributes) {
    super.updateAjaxAttributes(attributes);

    Map<Object, Object> map = new HashMap<>();
    map.put("answer", new JsExpression("39 + 3"));
    attributes.getDynamicExtraParameters().add(JsUtils.js(new JsReturn(JsLiteral.of(map))));
}

and then get it via

getRequest().getRequestParameters().getParameterValue("answer")

This is clumsy, but something you'll do quite often when interacting with frontend components via ajax.

Build breaks with Java 8

Because of various javadoc errors and syntax warnings

JsAjaxRequestTarget - custom implementation of AjaxRequestTarget

Delegates calls to a wrapped AjaxRequestTarget and provides functionality to add IJavaScript tokens.

JsIf negation

Allow to negate a JsIf Statement

Provide an OSGi Karaf feature

Expression/Statement String arguments

Replace any occurrence of String arguments with CharSequence where possible.

E.g.

public JsIf(String expression, IJsStatement thenBlock) {
    this(new JsExpression(expression), thenBlock);
}

Support for unary expression operators

http://www-archive.mozilla.org/js/language/grammar14.html#N-UnaryExpression

Setter for Options in WidgetBehavior

Options API for widget behavior

#12 will require some sort of easy API to set widget options (basically just a string key-value map)

JsCallBehavior to shorten the "single-call JsBehavior" idiom

add(new JsBehavior() {
    private static final long serialVersionUID = 1L;

    @Override
    protected IJavaScript domReadyJs() {
        return new JsCall("foo", arg);
    }
});

could be shortened to

add(new JsCallBehavior("foo", arg));

Convenient 'toString' methods to generate js strings

Having the toString methods of the actual IJavaScript tokens generate their own code probably isn't the best design decision, but would certainly make it easier to handle cases where wicket wants javascript strings, e.g. in

public void onClick(AjaxRequestTarget target) {
    target.prependJavaScript("alert('some javascript')");
}

maybe put a method into JsUtils that calls the necessary methods? Or put a static method directly into the generator?

Provide Wicket test setup

In order to use WicketTester

supports #14

AjaxLink that provides js callbacks

Options is not handled by the JsGenerator

Meaning it can not be serialized properly when used as argument to e.g. JsCall without calling .asObject() first.

WicketJsUtils#prepend calls AjaxRequestTarget#appendJavaScript

instead of AjaxRequestTarget#prependJavaScript

Make JSON serialization consider IJavaScript tokens

currently

map.put("property", new JsCall("get", "foobar"));
new JsObject(map);

would translate into

{"property":{"function":{"identifier":"get"},"arguments":[{"value":"foo"}]}}

what would be more sensible is

{"property": get('foo')}

org.rauschig.wicketjs.util.JsonSerializer (more the jackson ObjectMapper) has to be adapted for this.

Use of '_' as an identifier is deprecated in Java 8

_(...) is used throughout the API for chaining calls. It's kind of ugly anyway, but since Java 8 these are deprecated, so all of these method calls should be replaced/deprecated.

Relates to #28

Make JsLiteral, JsIdentifier and respective factory methods null safe

Calling e.g. new JsAssignment('foo', null) should compile to foo = null

Rename JsCompiler to JsGenerator

And related methods, which makes more sense, but will involves significant refactoring, especially in tests.

String escaping

Currently any type of string is quoted with single quotes. I haven't actually thought a whole lot about where and how to escape expression strings / string literals.

Look into cases where it might be required and implement this.