com.vaadin.flow.component.dependency.
Annotation Interface JavaScript
Defines JavaScript dependencies on a Component class. For adding
 multiple JavaScript files for a single component, you can use this annotation
 multiple times.
 
 It is guaranteed that dependencies will be loaded only once. The files loaded
 will be in the same order as the annotations were on the class. However,
 loading order is only guaranteed on a class level; Annotations from different
 classes may appear in different order, grouped by the annotated class. Also,
 files identified by @JavaScript will be loaded after
 JsModule and before
 CssImport.
 
 NOTE: Currently all frontend resources are bundled together into one big
 bundle. This means, that JavaScript files loaded by one class will be present
 on a view constructed by another class. For example, if there are two classes
 RootRoute annotated with @Route(""), and another class
 RouteA annotated with @Route("route-a") and
 @JavaScript("./src/javascript.js"), the javascript.js will be
 run on the root route as well.
 
 External JavaScript dependencies (e.g. "http://example.com/some.js") are
 added in the same way as Page.addJavaScript(String) and the result is
 just adding a classic javscript element to the page. Other paths used
 in the value() method are considered as relative to
 frontend directory and they are added to the page as a JavaScript
 module (a javscript element with type="module"). In this case
 a JavaScript annotation behaves exactly as a JsModule
 annotation.
 
It's not possible to execute a function defined in JavaScript module via
 
 UI.getCurrent().getPage().executeJs("some_function_definied_in_module()");
 
 
 because the function is private there (unless it's explicitly exposed). The
 JavaScript where the function is defined should be either external or it
 should be added using Page.addJavaScript(String): in this case all
 declared functions become available in the global scope.
Since:
1.0
Author:
Vaadin Ltd
See Also:
- 
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic @interfaceInternal annotation to enable use of multiple
JavaScriptannotations. - 
Required Element Summary
Required Elements - 
Optional Element Summary
Optional ElementsModifier and TypeOptional ElementDescriptionbooleanDefines if the JavaScript should be loaded only when running in development mode (for development tooling etc.) or if it should always be loaded.
Determines the dependency load mode.
 
- 
Element Details
- 
value
String valueJavaScript file URL to load before using the annotated
Componentin the browser.Relative URLs are interpreted as relative to the configured
frontenddirectory location.This URL identifies a file which will be bundled, so the file should be available to be able to bundle it.
You can prefix the URL with
context://to make it relative to the context path or use an absolute URL to refer to files outside the frontend directory. Such URLs are not bundled but included into the page as standalone scripts in the same way as it's done byPage.addJavaScript(String).Returns:
a JavaScript file URL
 
 - 
 - 
- 
developmentOnly
boolean developmentOnlyDefines if the JavaScript should be loaded only when running in development mode (for development tooling etc.) or if it should always be loaded.
By default, scripts are always loaded.
Default:
false
 - 
loadMode
LoadMode loadModeDetermines the dependency load mode. Refer to
LoadModefor the details.Returns:
load mode for the dependency
Default:
EAGER
 
 -