@angular/language-service 22.0.0-next.1 → 22.0.0-next.11

package/src/template_target.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AST, Call, SafeCall, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import tss from 'typescript';
+/**
+ * Contextual information for a target position within the template.
+ */
+export interface TemplateTarget {
+    /**
+     * Target position within the template.
+     */
+    position: number;
+    /**
+     * The template (or AST expression) node or nodes closest to the search position.
+     */
+    context: TargetContext;
+    /**
+     * The `TmplAstTemplate` which contains the found node or expression (or `null` if in the root
+     * template).
+     */
+    template: TmplAstTemplate | null;
+    /**
+     * The immediate parent node of the targeted node.
+     */
+    parent: TmplAstNode | AST | null;
+}
+/**
+ * A node or nodes targeted at a given position in the template, including potential contextual
+ * information about the specific aspect of the node being referenced.
+ *
+ * Some nodes have multiple interior contexts. For example, `TmplAstElement` nodes have both a tag
+ * name as well as a body, and a given position definitively points to one or the other.
+ * `TargetNode` captures the node itself, as well as this additional contextual disambiguation.
+ */
+export type TargetContext = SingleNodeTarget | MultiNodeTarget;
+/** Contexts which logically target only a single node in the template AST. */
+export type SingleNodeTarget = RawExpression | CallExpressionInArgContext | RawTemplateNode | ElementInBodyContext | ElementInTagContext | AttributeInKeyContext | AttributeInValueContext | ComponentInBodyContext | ComponentInTagContext | DirectiveInNameContext | DirectiveInBodyContext;
+/**
+ * Contexts which logically target multiple nodes in the template AST, which cannot be
+ * disambiguated given a single position because they are all equally relevant. For example, in the
+ * banana-in-a-box syntax `[(ngModel)]="formValues.person"`, the position in the template for the
+ * key `ngModel` refers to both the bound event `ngModelChange` and the input `ngModel`.
+ */
+export type MultiNodeTarget = TwoWayBindingContext;
+/**
+ * Differentiates the various kinds of `TargetNode`s.
+ */
+export declare enum TargetNodeKind {
+    RawExpression = 0,
+    CallExpressionInArgContext = 1,
+    RawTemplateNode = 2,
+    ElementInTagContext = 3,
+    ElementInBodyContext = 4,
+    AttributeInKeyContext = 5,
+    AttributeInValueContext = 6,
+    TwoWayBindingContext = 7,
+    ComponentInTagContext = 8,
+    ComponentInBodyContext = 9,
+    DirectiveInNameContext = 10,
+    DirectiveInBodyContext = 11
+}
+/**
+ * An `AST` expression that's targeted at a given position, with no additional context.
+ */
+export interface RawExpression {
+    kind: TargetNodeKind.RawExpression;
+    node: AST;
+    parents: AST[];
+}
+/**
+ * An `e.Call` expression with the cursor in a position where an argument could appear.
+ *
+ * This is returned when the only matching node is the method call expression, but the cursor is
+ * within the method call parentheses. For example, in the expression `foo(|)` there is no argument
+ * expression that the cursor could be targeting, but the cursor is in a position where one could
+ * appear.
+ */
+export interface CallExpressionInArgContext {
+    kind: TargetNodeKind.CallExpressionInArgContext;
+    node: Call | SafeCall;
+}
+/**
+ * A `TmplAstNode` template node that's targeted at a given position, with no additional context.
+ */
+export interface RawTemplateNode {
+    kind: TargetNodeKind.RawTemplateNode;
+    node: TmplAstNode;
+}
+/**
+ * A `TmplAstElement` (or `TmplAstTemplate`) element node that's targeted, where the given position
+ * is within the tag name.
+ */
+export interface ElementInTagContext {
+    kind: TargetNodeKind.ElementInTagContext;
+    node: TmplAstElement | TmplAstTemplate;
+}
+/**
+ * A `TmplAstElement` (or `TmplAstTemplate`) element node that's targeted, where the given position
+ * is within the element body.
+ */
+export interface ElementInBodyContext {
+    kind: TargetNodeKind.ElementInBodyContext;
+    node: TmplAstElement | TmplAstTemplate;
+}
+/**
+ * A `TmplAstComponent` element node that's targeted, where the given position is within the tag,
+ * e.g. `MyComp` in `<MyComp foo="bar"/>`.
+ */
+export interface ComponentInTagContext {
+    kind: TargetNodeKind.ComponentInTagContext;
+    node: TmplAstComponent;
+}
+/**
+ * A `TmplAstComponent` element node that's targeted, where the given position is within the body,
+ * e.g. `foo="bar"/>` in `<MyComp foo="bar"/>`.
+ */
+export interface ComponentInBodyContext {
+    kind: TargetNodeKind.ComponentInBodyContext;
+    node: TmplAstComponent;
+}
+/**
+ * A `TmplAstDirective` element node that's targeted, where the given position is within the
+ * directive's name (e.g. `MyDir` in `@MyDir`).
+ */
+export interface DirectiveInNameContext {
+    kind: TargetNodeKind.DirectiveInNameContext;
+    node: TmplAstDirective;
+}
+/**
+ * A `TmplAstDirective` element node that's targeted, where the given position is within the body,
+ * e.g. `(foo="bar")` in `@MyDir(foo="bar")`.
+ */
+export interface DirectiveInBodyContext {
+    kind: TargetNodeKind.DirectiveInBodyContext;
+    node: TmplAstDirective;
+}
+export interface AttributeInKeyContext {
+    kind: TargetNodeKind.AttributeInKeyContext;
+    node: TmplAstTextAttribute | TmplAstBoundAttribute | TmplAstBoundEvent;
+}
+export interface AttributeInValueContext {
+    kind: TargetNodeKind.AttributeInValueContext;
+    node: TmplAstTextAttribute | TmplAstBoundAttribute | TmplAstBoundEvent;
+}
+/**
+ * A `TmplAstBoundAttribute` and `TmplAstBoundEvent` pair that are targeted, where the given
+ * position is within the key span of both.
+ */
+export interface TwoWayBindingContext {
+    kind: TargetNodeKind.TwoWayBindingContext;
+    nodes: [TmplAstBoundAttribute, TmplAstBoundEvent];
+}
+/**
+ * Return the template AST node or expression AST node that most accurately
+ * represents the node at the specified cursor `position`.
+ *
+ * @param template AST tree of the template
+ * @param position target cursor position
+ */
+export declare function getTargetAtPosition(template: TmplAstNode[], position: number): TemplateTarget | null;
+/**
+ * A tcb nodes for the template at a given position, include the tcb node of the template.
+ */
+interface TcbNodesInfoForTemplate {
+    componentTcbNode: tss.Node;
+    nodes: tss.Node[];
+}
+/**
+ * Return the nodes in `TCB` of the node at the specified cursor `position`.
+ *
+ */
+export declare function getTcbNodesOfTemplateAtPosition(templateNodes: TmplAstNode[], position: number, tcb: tss.Node): TcbNodesInfoForTemplate | null;
+export {};

package/src/ts_plugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type ts from 'typescript';
+import { NgLanguageService } from '../api';
+export declare function create(info: ts.server.PluginCreateInfo): NgLanguageService;
+/** Implementation of a ts.server.PluginModuleFactory */
+export declare function initialize(mod: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;

package/src/utils/decorators.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type ts from 'typescript';
+import { ReflectionHost } from '@angular/compiler-cli';
+export declare function isDirectiveOrComponent(node: ts.ClassDeclaration, reflector: ReflectionHost): boolean;

package/src/utils/display_parts.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { LetDeclarationSymbol, PotentialDirective, ReferenceSymbol, TemplateTypeChecker, VariableSymbol } from '@angular/compiler-cli';
+import ts from 'typescript';
+export declare const ALIAS_NAME: string;
+export declare const SYMBOL_INTERFACE: string;
+export declare const SYMBOL_PUNC: string;
+export declare const SYMBOL_SPACE: string;
+export declare const SYMBOL_TEXT: string;
+/**
+ * Label for various kinds of Angular entities for TS display info.
+ */
+export declare enum DisplayInfoKind {
+    ATTRIBUTE = "attribute",
+    BLOCK = "block",
+    TRIGGER = "trigger",
+    COMPONENT = "component",
+    DIRECTIVE = "directive",
+    EVENT = "event",
+    REFERENCE = "reference",
+    ELEMENT = "element",
+    VARIABLE = "variable",
+    PIPE = "pipe",
+    PROPERTY = "property",
+    METHOD = "method",
+    TEMPLATE = "template",
+    KEYWORD = "keyword",
+    LET = "let"
+}
+export interface DisplayInfo {
+    kind: DisplayInfoKind;
+    displayParts: ts.SymbolDisplayPart[];
+    documentation: ts.SymbolDisplayPart[] | undefined;
+    tags: ts.JSDocTagInfo[] | undefined;
+}
+export declare function getSymbolDisplayInfo(tsLS: ts.LanguageService, typeChecker: ts.TypeChecker, symbol: ReferenceSymbol | VariableSymbol | LetDeclarationSymbol, templateTypeChecker: TemplateTypeChecker): DisplayInfo;
+/**
+ * Construct a compound `ts.SymbolDisplayPart[]` which incorporates the container and type of a
+ * target declaration.
+ * @param name Name of the target
+ * @param kind component, directive, pipe, etc.
+ * @param containerName either the Symbol's container or the NgModule that contains the directive
+ * @param type user-friendly name of the type
+ * @param documentation docstring or comment
+ */
+export declare function createDisplayParts(name: string, kind: DisplayInfoKind, containerName: string | undefined, type: string | undefined): ts.SymbolDisplayPart[];
+/**
+ * Convert a `SymbolDisplayInfoKind` to a `ts.ScriptElementKind` type, allowing it to pass through
+ * TypeScript APIs.
+ *
+ * In practice, this is an "illegal" type cast. Since `ts.ScriptElementKind` is a string, this is
+ * safe to do if TypeScript only uses the value in a string context. Consumers of this conversion
+ * function are responsible for ensuring this is the case.
+ */
+export declare function unsafeCastDisplayInfoKindToScriptElementKind(kind: DisplayInfoKind): ts.ScriptElementKind;
+export declare function getDirectiveDisplayInfo(tsLS: ts.LanguageService, dir: PotentialDirective): DisplayInfo;
+export declare function getTsSymbolDisplayInfo(tsLS: ts.LanguageService, checker: ts.TypeChecker, symbol: ts.Symbol, kind: DisplayInfoKind, ownerName: string | null): DisplayInfo | null;

package/src/utils/format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import ts from 'typescript';
+/**
+ * Try to guess the indentation of the node.
+ *
+ * This function returns the indentation only if the start character of this node is
+ * the first non-whitespace character in a line where the node is, otherwise,
+ * it returns `undefined`. When computing the start of the node, it should include
+ * the leading comments.
+ */
+export declare function guessIndentationInSingleLine(node: ts.Node, sourceFile: ts.SourceFile): number | undefined;

package/src/utils/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AbsoluteSourceSpan, AST, ParseSourceSpan, ParseSpan, PropertyRead, TmplAstBoundEvent, TmplAstElement, TmplAstNode, TmplAstTemplate } from '@angular/compiler';
+import { AbsoluteFsPath, DirectiveSymbol, NgCompiler, TemplateTypeChecker } from '@angular/compiler-cli';
+import ts from 'typescript';
+import { DisplayInfoKind } from './display_parts';
+export declare function getTextSpanOfNode(node: TmplAstNode | AST): ts.TextSpan;
+export declare function toTextSpan(span: AbsoluteSourceSpan | ParseSourceSpan | ParseSpan): ts.TextSpan;
+interface NodeWithKeyAndValue extends TmplAstNode {
+    keySpan: ParseSourceSpan;
+    valueSpan?: ParseSourceSpan;
+}
+export declare function isTemplateNodeWithKeyAndValue(node: TmplAstNode | AST): node is NodeWithKeyAndValue;
+export declare function isWithinKey(position: number, node: NodeWithKeyAndValue): boolean;
+export declare function isWithinKeyValue(position: number, node: NodeWithKeyAndValue): boolean;
+export declare function isTemplateNode(node: TmplAstNode | AST): node is TmplAstNode;
+export declare function isExpressionNode(node: TmplAstNode | AST): node is AST;
+export interface TypeCheckInfo {
+    nodes: TmplAstNode[];
+    declaration: ts.ClassDeclaration;
+}
+/**
+ * Retrieves the `ts.ClassDeclaration` at a location along with its template AST nodes.
+ */
+export declare function getTypeCheckInfoAtPosition(fileName: string, position: number, compiler: NgCompiler): TypeCheckInfo | undefined;
+export declare function getFirstComponentForTemplateFile(fileName: string, compiler: NgCompiler): TypeCheckInfo | undefined;
+/**
+ * Given an element or template, determines which directives match because the tag is present. For
+ * example, if a directive selector is `div[myAttr]`, this would match div elements but would not if
+ * the selector were just `[myAttr]`. We find which directives are applied because of this tag by
+ * elimination: compare the directive matches with the tag present against the directive matches
+ * without it. The difference would be the directives which match because the tag is present.
+ *
+ * @param element The element or template node that the attribute/tag is part of.
+ * @param directives The list of directives to match against.
+ * @returns The list of directives matching the tag name via the strategy described above.
+ */
+export declare function getDirectiveMatchesForElementTag<T extends {
+    selector: string | null;
+}>(element: TmplAstTemplate | TmplAstElement, directives: T[]): Set<T>;
+export declare function makeElementSelector(element: TmplAstElement | TmplAstTemplate): string;
+/**
+ * Given an attribute name, determines which directives match because the attribute is present. We
+ * find which directives are applied because of this attribute by elimination: compare the directive
+ * matches with the attribute present against the directive matches without it. The difference would
+ * be the directives which match because the attribute is present.
+ *
+ * @param name The name of the attribute
+ * @param hostNode The node which the attribute appears on
+ * @param directives The list of directives to match against.
+ * @returns The list of directives matching the tag name via the strategy described above.
+ */
+export declare function getDirectiveMatchesForAttribute(name: string, hostNode: TmplAstTemplate | TmplAstElement, directives: DirectiveSymbol[]): Set<DirectiveSymbol>;
+/**
+ * Returns a new `ts.SymbolDisplayPart` array which has the alias imports from the tcb filtered
+ * out, i.e. `i0.NgForOf`.
+ */
+export declare function filterAliasImports(displayParts: ts.SymbolDisplayPart[]): ts.SymbolDisplayPart[];
+export declare function isDollarEvent(n: TmplAstNode | AST): n is PropertyRead;
+export declare function isTypeScriptFile(fileName: string): boolean;
+export declare function isExternalTemplate(fileName: string): boolean;
+export declare function isWithin(position: number, span: AbsoluteSourceSpan | ParseSourceSpan): boolean;
+/**
+ * For a given location in a shim file, retrieves the corresponding file url for the template and
+ * the span in the template.
+ */
+export declare function getTemplateLocationFromTcbLocation(templateTypeChecker: TemplateTypeChecker, tcbPath: AbsoluteFsPath, tcbIsShim: boolean, positionInFile: number): {
+    templateUrl: AbsoluteFsPath;
+    span: ParseSourceSpan;
+} | null;
+export declare function isBoundEventWithSyntheticHandler(event: TmplAstBoundEvent): boolean;
+/**
+ * Construct a QuickInfo object taking into account its container and type.
+ * @param name Name of the QuickInfo target
+ * @param kind component, directive, pipe, etc.
+ * @param textSpan span of the target
+ * @param containerName either the Symbol's container or the NgModule that contains the directive
+ * @param type user-friendly name of the type
+ * @param documentation docstring or comment
+ */
+export declare function createQuickInfo(name: string, kind: DisplayInfoKind, textSpan: ts.TextSpan, containerName?: string, type?: string, documentation?: ts.SymbolDisplayPart[], tags?: ts.JSDocTagInfo[]): ts.QuickInfo;
+export {};

package/src/utils/ts_utils.d.ts

@@ -0,0 +1,138 @@
+import { NgCompiler, PotentialDirective, PotentialPipe, SymbolReference, TemplateTypeChecker } from '@angular/compiler-cli';
+import ts from 'typescript';
+/**
+ * Return the node that most tightly encompasses the specified `position`.
+ * @param node The starting node to start the top-down search.
+ * @param position The target position within the `node`.
+ */
+export declare function findTightestNode(node: ts.Node, position: number): ts.Node | undefined;
+export interface FindOptions<T extends ts.Node> {
+    filter: (node: ts.Node) => node is T;
+    position?: number;
+}
+/**
+ * Finds TypeScript nodes descending from the provided root which match the given filter.
+ */
+export declare function findAllMatchingNodes<T extends ts.Node>(root: ts.Node, opts: FindOptions<T>): T[];
+/**
+ * Finds TypeScript nodes descending from the provided root which match the given filter.
+ */
+export declare function findFirstMatchingNode<T extends ts.Node>(root: ts.Node, opts: FindOptions<T>): T | null;
+/**
+ * Resolves a ClassDeclaration from a SymbolReference.
+ */
+export declare function getClassDeclarationFromSymbolReference(ls: ts.LanguageService, ref: SymbolReference): ts.ClassDeclaration | null;
+export declare function getParentClassDeclaration(startNode: ts.Node): ts.ClassDeclaration | undefined;
+/**
+ * Returns a property assignment from the assignment value if the property name
+ * matches the specified `key`, or `null` if there is no match.
+ */
+export declare function getPropertyAssignmentFromValue(value: ts.Node, key: string): ts.PropertyAssignment | null;
+/**
+ * Given a decorator property assignment, return the ClassDeclaration node that corresponds to the
+ * directive class the property applies to.
+ * If the property assignment is not on a class decorator, no declaration is returned.
+ *
+ * For example,
+ *
+ * @Component({
+ *   template: '<div></div>'
+ *   ^^^^^^^^^^^^^^^^^^^^^^^---- property assignment
+ * })
+ * class AppComponent {}
+ *           ^---- class declaration node
+ *
+ * @param propAsgnNode property assignment
+ */
+export declare function getClassDeclFromDecoratorProp(propAsgnNode: ts.PropertyAssignment): ts.ClassDeclaration | undefined;
+/**
+ * Collects all member methods, including those from base classes.
+ */
+export declare function collectMemberMethods(clazz: ts.ClassDeclaration, typeChecker: ts.TypeChecker): ts.MethodDeclaration[];
+/**
+ * Given an existing array literal expression, update it by pushing a new expression.
+ */
+export declare function addElementToArrayLiteral(arr: ts.ArrayLiteralExpression, elem: ts.Expression): ts.ArrayLiteralExpression;
+/**
+ * Given an ObjectLiteralExpression node, extract and return the PropertyAssignment corresponding to
+ * the given key. `null` if no such key exists.
+ */
+export declare function objectPropertyAssignmentForKey(obj: ts.ObjectLiteralExpression, key: string): ts.PropertyAssignment | null;
+/**
+ * Given an ObjectLiteralExpression node, create or update the specified key, using the provided
+ * callback to generate the new value (possibly based on an old value), and return the `ts.PropertyAssignment`
+ * for the key.
+ */
+export declare function updateObjectValueForKey(obj: ts.ObjectLiteralExpression, key: string, newValueFn: (oldValue?: ts.Expression) => ts.Expression): ts.PropertyAssignment;
+/**
+ * Create a new ArrayLiteralExpression, or accept an existing one.
+ * Ensure the array contains the provided identifier.
+ * Returns the array, either updated or newly created.
+ * If no update is needed, returns `null`.
+ */
+export declare function ensureArrayWithIdentifier(identifierText: string, expression: ts.Expression, arr?: ts.ArrayLiteralExpression): ts.ArrayLiteralExpression | null;
+/**
+ * Determine whether this an import of the given `propertyName` from a particular module
+ * specifier already exists. If so, return the local name for that import, which might be an
+ * alias.
+ */
+export declare function hasImport(importDeclarations: ts.ImportDeclaration[], propName: string, moduleSpecifier: string): string | null;
+/**
+ * Transform the given import name into an alias that does not collide with any other import
+ * symbol.
+ */
+export declare function nonCollidingImportName(importDeclarations: ts.ImportDeclaration[], name: string): string;
+/**
+ * If the provided trait is standalone, just return it. Otherwise, returns the owning ngModule.
+ */
+export declare function standaloneTraitOrNgModule(checker: TemplateTypeChecker, trait: ts.ClassDeclaration): ts.ClassDeclaration | null;
+/**
+ * Updates the imports on a TypeScript file, by ensuring the provided import is present.
+ * Returns the text changes, as well as the name with which the imported symbol can be referred to.
+ *
+ * When the component is exported by default, the `symbolName` is `default`, and the `declarationName`
+ * should be used as the import name.
+ */
+export declare function updateImportsForTypescriptFile(file: ts.SourceFile, symbolName: string, declarationName: string, moduleSpecifier: string): [ts.TextChange[], string];
+/**
+ * Updates a given Angular trait, such as an NgModule or standalone Component, by adding
+ * `importName` to the list of imports on the decorator arguments.
+ */
+export declare function updateImportsForAngularTrait(checker: TemplateTypeChecker, trait: ts.ClassDeclaration, importName: string, forwardRefName: string | null): ts.TextChange[];
+/**
+ * Return whether a given Angular decorator specifies `standalone: true`.
+ */
+export declare function isStandaloneDecorator(decorator: ts.Decorator): boolean | null;
+/**
+ * Generate a new import. Follows the format:
+ * ```ts
+ * import {exportedSpecifierName as localName} from 'rawModuleSpecifier';
+ * ```
+ *
+ * If the component is exported by default, follows the format:
+ *
+ * ```ts
+ * import exportedSpecifierName from 'rawModuleSpecifier';
+ * ```
+ *
+ * If `exportedSpecifierName` is null, or is equal to `name`, then the qualified import alias will
+ * be omitted.
+ */
+export declare function generateImport(localName: string, exportedSpecifierName: string | null, rawModuleSpecifier: string): ts.ImportDeclaration;
+/**
+ * Update an existing named import with a new member.
+ * If `exportedSpecifierName` is null, or is equal to `name`, then the qualified import alias will
+ * be omitted.
+ * If the `localName` is `default` and `exportedSpecifierName` is not null, the `exportedSpecifierName`
+ * is used as the default import name.
+ */
+export declare function updateImport(importDeclaration: ts.ImportDeclaration, localName: string, exportedSpecifierName: string | null): ts.ImportClause | undefined;
+/**
+ * Print a given TypeScript node into a string. Used to serialize entirely synthetic generated AST,
+ * which will not have `.text` or `.fullText` set.
+ */
+export declare function printNode(node: ts.Node, sourceFile: ts.SourceFile): string;
+/**
+ * Get the code actions to tell the vscode how to import the directive into the standalone component or ng module.
+ */
+export declare function getCodeActionToImportTheDirectiveDeclaration(compiler: NgCompiler, component: ts.ClassDeclaration, importOn: ts.ClassDeclaration, directive: PotentialDirective | PotentialPipe, tsLs: ts.LanguageService, includeCompletionsForModuleExports?: boolean): ts.CodeAction[] | undefined;