All Classes and Interfaces
Class
Description
An abstract base class that holds common information about a component
extracted from Java source code during code analysis.
Utility class for figuring out access requirements for Java methods such as
routes and browser callables.
Command handler for AI related operations
Thrown when the user tries to use some AI functionality but AI usage is
disabled (either through the subscription or by the user).
Client for tracking features of Copilot
Tracking request
Helps to initialize a Spring Boot Vaadin application with no views by adding
either a Flow or Hilla view + a theme.
Assertion scenario item represents Assertion conditions in TestBench test.
Represents the expression where a component has been attached to its parent.
Returns the class name of given component.
Class name request is requested when Hilla+React component is selected to
find the existing class name or suggested one
Returns class name of selected Hilla component suggested or existing one
depends on if class name is exist in theme editor.
Static source file parser for the given component class.
A consumer that listens to IDE heartbeat responses to detect and react to
changes in compilation status.
A simple record to represent a file path and its corresponding file name.
Holds information about a component's attachment within the Java source code.
Represents metadata related to the creation of a component within a Java
source file.
Represents metadata information about a Vaadin
Component.Builder pattern for
ComponentInfo classResponsible for locating and aggregating information about a UI component's
creation and attachment within a Java project.
Contains information for each node instance that is required for custom
component support.
Handles component specific commands
A record that encapsulates metadata about a component's drag-and-drop API
support.
Happens when component info not found for unknown reasons.
Helper util for properties panel to handle parsing and obtaining data from
JSON
Holds metadata about a component property field, including its type, whether
it supports multiple selection, and the fully qualified name of its
associated class.
Property types that properties panel supports
Finds the source location of a component in the project.
Information about a component in the source code.
Utility class to create JSON response from Configuration files and save
configuration data from request
Utility class for connecting to a service method.
The type of binding that can be used for a Flow Grid.
This is the entry point for copilot.
Base class for all classes that handle Copilot commands from the browser.
Editor extension to write file content
Generic exception for Copilot which exists mainly to make it easy to see that
an exception originated inside Copilot.
IDE plugin support utility
Base class for Copilot Server API clients
The main code for Copilot for a given VaadinSession instance.
Utility class for reading the Copilot version.
Crud component handler.
A wrapper class for custom component.
Type of the custom component.
Provides information about component is whether a custom component or not.
Contains information for custom components that are defined outside the
project. e.g. addon, external maven libraries etc...
CustomComponentHandle is the backbone of creating statement for custom
components such as Grids, Charts etc...
Helper class for custom components
Contains information for custom components that are found in project sources.
Contains information about custom component instance.
Contains all the information that is required for the UI to have custom
component support.
Contains the map of detected custom component classes
Handlers for Dashboard, DashboardSection, DashboardWidget components
Class/Record definition related functions for Java Rewriter This class
generates a record/class to host data entities used in advanced data
components like Grid
Exception that is thrown when a component class is not accessible through
reflection API.
Handler for development environment setup.
ErrorsRequest message
Represents a report for tracking exceptions within an application.
A builder-style class used to construct an
ExceptionReport instance.Represents a file-based item within an
ExceptionReport.A generic interface that represents what items should return for reporting an
issue.
Represents a reference to a relevant UI component node within the context of
an exception report.
Class that contains information key value pair that is useful for identifying
the exception.
Feedback Request
Collects and caches default values of a component by instantiating a new
instance from
Class and by calling getter methodsThis class contains hacks related to Flow components and how they work.
A class for downloading the Hotswap Agent JAR file.
Handles the downloading and setting up hotswap related tools for the project
Command handler for i18n related operations
Represents the response payload from the IDE heartbeat mechanism.
A scheduler implementation that sends a request to IDE plugin in an interval
and shares the response with consumers.
Integration with IDEs for development mode.
A Set implementation that uses identity comparison instead of equals.
Utility class for currently used IDE
Represents a point in the source code where new code can be inserted.
Deprecated, for removal: This API element is subject to removal in a future version.
It is deprecated and needs to be removed because JavaRewriter and
CompilationUnit have been decoupled in recent changes.
Represents a Java component to be added to the source code.
Metadata for the copied component.
Handler for data provider changes.
Provider that makes sure same JavaRewriter is served for the same file so
same file should not be overwritten in the same operation.
A utility class for modifying Java source code.
A class for performing operations on a CompilationUnit.
A functional interface for operations that modify a CompilationUnit.
Handles commands to parse Java source code.
Holds data for a Java annotation.
Holds data for a Java bean property.
Represents a method in a component class that can be used to add child
components.
Handles commands to rewrite Java source code.
Rewrites Java source code to add or replace constructor parameters, method
invocations and more.
A code snippet to be inserted into the source code.
Enum representing the type of comment to be added.
The result of a duplicate operation
Information about extracting an inline variable to local variable
Information about a renamed variable.
Holder for a setter name and associated value
Where to add a component
Handles the copy & paste functionality for flow components.
Handles merging of the original source file with changes perform to the AST.
Observer for the JavaRewriter that tracks which parts have been deleted and
which nodes have potentially been added or modified.
Util methods for rewriting Java
Represents a Java source file that can be parsed and rewritten using a custom
observer and parser configuration.
Detects the source folders in use by the project.
Available Hotswap solutions.
Utility class for downloading and referencing a JetBrains Runtime.
The exception is thrown for operations that are not supported e.g.
Class/Record definition related functions for Java Rewriter.
Implementation of
GenericVisitor
that finds Node at given line of source code file.Implementation of
GenericVisitor
that searches for classnames applied to given component.Implementation of
GenericVisitor
that searches for local classname expression statement by comparing
expression type, method call scope and expression comment.Handles listing, supplying templates of new views that will be created by New
Route Panel.
Contains information to generate new Flow view
Contains information to generate new Flow view
Assertion scenario to generate the statements like
Assertion.assertEquals("foo", getDriver().getTitle())Pom File rewriter handles modifications for the given pom file by copying
original file to temporary file.
Dependency that presents in the pom.xml
Property that presents in the pom.xml
This class represents a possible selector of a target element.
Explicitly selected attribute by the user.
Assertion statement like
ExpectedConditions.visibilityOf(....)Copilot 7-day preview handler.
Handler for stored project state configuration operations.
Handles creation of views for new routes.
Provides server side route information to the client.
The
SourceSyncChecker is responsible for monitoring changes to Java
source files during development to identify scenarios where source files may
be out of sync with the running application or route view is deleted by the
user.Acts as a bridge between Copilot and Spring specific API.
Provides Spring related helpers for copilot.
Provides Spring security related helpers for copilot.
Implementation of
GenericVisitor
that finds Statement at given line of source code file.StreamResponse is a record class used for sending responses to the client
when the '/stream' endpoint is accessed.
Enum for stream response statuses: This enum contains the four steps we go
through while responding to the client:
1.
Exception that suggests to restart the application.
Enumeration of supported event names that can be used to target specific UI
interactions.
Represents a scenario item that targets a specific UI element within a
TestBench test scenario.
This class represents the targeted element information.
Represent the successful result of generating the test.
Generates a TestBench tests using the JavaParser with the given scenario.
Handler that handles commands to generate recorded test bench tests
Represents the scenario generated by the test bench record plugin.
Base class for each scenario items to generate tests.
Represents the type of item of a scenario item.
Assertion statement for statements like
Assertions.assertEquals("foo", textField.getText()); Handler for ThemeEditor debug window communication messages.
Error used while theme is not configured in current project.
UIServiceCreator is responsible for generating Java service and bean classes
dynamically.
Represents information about a Java bean.
Represents information about a field in a Java bean.
Represents information about a service and its associated bean.
Provides endpoint information to the client.
Handles getting information about the user (pro key based) and communicating
with the server about feature access.
Handles updating the Vaadin version in a project using Maven.
Handler for displaying and upgrading to new versions
Request data for copilot server to fetch new versions after given version.
Utility class for configuring VS Code for hot code replace and Hotswap Agent
launch configurations.
Finds components in the project and relevant dependencies that can be listed
as options in Wrap With function.
Info about the class name