@openrewrite/recipes-angular 1.9.0 → 1.10.0-20260813-195315

package/src/migration/add-istanbul-instrumenter.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {detectIndent, getMemberKeyName, isObject, Json, JsonVisitor} from "@openrewrite/rewrite/json";
+import {addMemberPath, literal, memberIndent} from "./json-support";
+
+const PACKAGE = 'istanbul-lib-instrument';
+const VERSION = '^6.0.3';
+
+const DEPENDENCY_SCOPES = ['dependencies', 'devDependencies'];
+
+export class AddIstanbulInstrumenter extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-istanbul-instrumenter";
+    readonly displayName: string = "Add `istanbul-lib-instrument` for Karma code coverage";
+    readonly description: string = "Adds `istanbul-lib-instrument` to `devDependencies` of projects that still depend on Karma. " +
+        "Angular 22 stopped bundling the instrumenter, so Karma code coverage fails without it. " +
+        "Run an install afterwards to refresh the lock file.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!doc.sourcePath.endsWith('package.json')) return doc;
+
+                const root = doc.value;
+                if (!isObject(root)) return doc;
+
+                const declared = declaredPackages(root);
+                if (declared.has(PACKAGE)) return doc;
+                if (![...declared].some(name => name === 'karma' || name.startsWith('karma-'))) return doc;
+
+                const indentUnit = detectIndent(doc);
+                const value = addMemberPath(root, ['devDependencies', PACKAGE],
+                    literal(`"${VERSION}"`, VERSION), memberIndent(root, indentUnit), indentUnit);
+
+                return value === root ? doc : {...doc, value} as Json.Document;
+            }
+        }();
+    }
+}
+
+function declaredPackages(root: Json.Object): Set<string> {
+    const declared = new Set<string>();
+    for (const rp of root.members) {
+        const member = rp.element;
+        if (member.kind !== Json.Kind.Member) continue;
+        if (!DEPENDENCY_SCOPES.includes(getMemberKeyName(member as Json.Member) ?? '')) continue;
+
+        const scope = (member as Json.Member).value;
+        if (!isObject(scope)) continue;
+
+        for (const dep of scope.members) {
+            if (dep.element.kind !== Json.Kind.Member) continue;
+            const name = getMemberKeyName(dep.element as Json.Member);
+            if (name) declared.add(name);
+        }
+    }
+    return declared;
+}

package/src/migration/add-no-incremental-hydration.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, Template} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+const HYDRATION_FEATURES = ['withIncrementalHydration', 'withNoIncrementalHydration'];
+
+export class AddNoIncrementalHydration extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-no-incremental-hydration";
+    readonly displayName: string = "Add `withNoIncrementalHydration()` to `provideClientHydration()`";
+    readonly description: string = "Adds the `withNoIncrementalHydration()` opt out to `provideClientHydration()` calls that do not " +
+        "already configure incremental hydration. Angular 22 enables incremental hydration by default; the opt out retains the previous behavior.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m || m.name.simpleName !== 'provideClientHydration') return m;
+
+                const elements = (m.arguments?.elements ?? []).filter(rp => rp.element.kind !== J.Kind.Empty);
+                if (elements.some(rp => isHydrationFeatureCall(rp.element))) return m;
+
+                maybeAddImport(this, {
+                    module: '@angular/platform-browser',
+                    member: 'withNoIncrementalHydration',
+                    onlyIfReferenced: false
+                });
+
+                let builder = Template.builder().code('provideClientHydration(');
+                for (const element of elements) {
+                    builder = builder.param(element.element).code(', ');
+                }
+                const t = builder.code('withNoIncrementalHydration())').build();
+                return await t.apply(m, this.cursor);
+            }
+        }();
+    }
+}
+
+function isHydrationFeatureCall(expression: J): boolean {
+    if (expression.kind !== J.Kind.MethodInvocation) return false;
+    const invocation = expression as J.MethodInvocation;
+    return isIdentifier(invocation.name) && HYDRATION_FEATURES.includes(invocation.name.simpleName);
+}

package/src/migration/add-strict-templates-false.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, ExecutionContext, randomId, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {detectIndent, getMemberKeyName, isMember, isObject, Json, JsonVisitor, rightPadded, space} from "@openrewrite/rewrite/json";
+import {appendMember, buildMember, declaresAngularCompilerOptions, isRootTsconfig, literal, memberIndent} from "./json-support";
+
+export class AddStrictTemplatesFalse extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-strict-templates-false";
+    readonly displayName: string = "Add `strictTemplates: false` to `tsconfig.json`";
+    readonly description: string = "Adds `\"strictTemplates\": false` to `angularCompilerOptions` in `tsconfig.json` when the option is not set. " +
+        "Angular 22 turned strict template type checking on by default; setting it explicitly avoids new compilation errors.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            private baseIndent = '  ';
+
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                this.baseIndent = detectIndent(doc);
+
+                if (declaresAngularCompilerOptions(doc)) return super.visitDocument(doc, p);
+                if (!isRootTsconfig(doc.sourcePath)) return doc;
+
+                const root = doc.value;
+                if (!isObject(root)) return doc;
+
+                const indent = memberIndent(root, this.baseIndent);
+                const newMember = buildMember('angularCompilerOptions', {
+                    kind: Json.Kind.Object,
+                    id: randomId(),
+                    prefix: space(' '),
+                    markers: emptyMarkers,
+                    members: [rightPadded(
+                        buildMember('strictTemplates', literal('false', false), '\n' + indent + this.baseIndent),
+                        space('\n' + indent))],
+                } as Json.Object, '\n' + indent);
+
+                return {...doc, value: appendMember(root, newMember, '\n')} as Json.Document;
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!m) return m;
+
+                if (getMemberKeyName(m) !== 'angularCompilerOptions' || !isObject(m.value)) return m;
+
+                const options = m.value as Json.Object;
+                const hasStrictTemplates = options.members.some(rp =>
+                    isMember(rp.element) && getMemberKeyName(rp.element as Json.Member) === 'strictTemplates');
+                if (hasStrictTemplates) return m;
+
+                const indent = memberIndent(options, this.baseIndent.repeat(2));
+                const newMember = buildMember('strictTemplates', literal('false', false), '\n' + indent);
+
+                return {...m, value: appendMember(options, newMember, '\n' + this.baseIndent)} as Json.Member;
+            }
+        }();
+    }
+}

package/src/migration/add-trust-proxy-headers.ts

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, Template} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+const APP_ENGINES = ['AngularNodeAppEngine', 'AngularAppEngine'];
+
+const TODO_COMMENT = "// TODO: This is a security-sensitive option. Remove if not needed. " +
+    "For more information, see https://angular.dev/best-practices/security#configuring-trusted-proxy-headers";
+
+export class AddTrustProxyHeaders extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-trust-proxy-headers";
+    readonly displayName: string = "Add `trustProxyHeaders` to the Angular app engine";
+    readonly description: string = "Adds `trustProxyHeaders: ['x-forwarded-host', 'x-forwarded-proto']` to " +
+        "`new AngularNodeAppEngine()` and `new AngularAppEngine()`. Angular 22 stopped trusting forwarded headers " +
+        "by default; the option restores the previous behavior and carries a TODO to remove it when the server " +
+        "does not sit behind a trusted proxy.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitNewClass(newClass: J.NewClass, p: ExecutionContext): Promise<J | undefined> {
+                const n = await super.visitNewClass(newClass, p) as J.NewClass;
+                if (!n || !n.class || !isIdentifier(n.class) || !APP_ENGINES.includes(n.class.simpleName)) return n;
+
+                const args = (n.arguments?.elements ?? []).filter(rp => rp.element.kind !== J.Kind.Empty);
+                if (args.length > 1) return n;
+
+                const options = args.length === 1 ? args[0].element : undefined;
+                if (options && options.kind !== J.Kind.NewClass) return n;
+                if (options && declaresTrustProxyHeaders(options as J.NewClass)) return n;
+
+                const engine = n.class.simpleName;
+                const existing = (options as J.NewClass | undefined)?.body?.statements
+                    .filter(rp => rp.element.kind !== J.Kind.Empty) ?? [];
+
+                let builder = Template.builder().code(`new ${engine}({\n  ${TODO_COMMENT}\n  trustProxyHeaders: ['x-forwarded-host', 'x-forwarded-proto'],`);
+                for (const statement of existing) {
+                    builder = builder.code('\n  ').param(statement.element).code(',');
+                }
+                const t = builder.code('\n})').build();
+                return await t.apply(n, this.cursor);
+            }
+        }();
+    }
+}
+
+function declaresTrustProxyHeaders(options: J.NewClass): boolean {
+    return (options.body?.statements ?? []).some(rp => {
+        const element = rp.element;
+        // A spread may supply the option from elsewhere, which we cannot see from here
+        if (element.kind === JS.Kind.Spread) return true;
+        if (element.kind !== JS.Kind.PropertyAssignment) return false;
+        const name = (element as JS.PropertyAssignment).name.element;
+        return isIdentifier(name) && name.simpleName === 'trustProxyHeaders';
+    });
+}

package/src/migration/add-with-xhr.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, Template} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+const BACKEND_FEATURES = ['withFetch', 'withXhr'];
+
+export class AddWithXhr extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.add-with-xhr";
+    readonly displayName: string = "Add `withXhr()` to `provideHttpClient()`";
+    readonly description: string = "Adds `withXhr()` to `provideHttpClient()` calls that select neither a `withFetch()` nor a " +
+        "`withXhr()` backend. Angular 22 made `FetchBackend` the default `HttpBackend`; `withXhr()` keeps the previous " +
+        "`XMLHttpRequest` based backend, which is also the only one that reports upload progress.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m || m.select || !isIdentifier(m.name) || m.name.simpleName !== 'provideHttpClient') return m;
+
+                const elements = (m.arguments?.elements ?? []).filter(rp => rp.element.kind !== J.Kind.Empty);
+                if (elements.some(rp => isBackendFeatureCall(rp.element))) return m;
+
+                maybeAddImport(this, {
+                    module: '@angular/common/http',
+                    member: 'withXhr',
+                    onlyIfReferenced: false
+                });
+
+                let builder = Template.builder().code('provideHttpClient(');
+                for (const element of elements) {
+                    builder = builder.param(element.element).code(', ');
+                }
+                const t = builder.code('withXhr())').build();
+                return await t.apply(m, this.cursor);
+            }
+        }();
+    }
+}
+
+function isBackendFeatureCall(expression: J): boolean {
+    if (expression.kind !== J.Kind.MethodInvocation) return false;
+    const invocation = expression as J.MethodInvocation;
+    return !invocation.select && isIdentifier(invocation.name) && BACKEND_FEATURES.includes(invocation.name.simpleName);
+}

package/src/migration/js-support.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, randomId} from "@openrewrite/rewrite";
+import {JS} from "@openrewrite/rewrite/javascript";
+import {emptySpace, J, singleSpace} from "@openrewrite/rewrite/java";
+
+export function buildPropertyAssignment(key: string, value: string): any {
+    return {
+        kind: JS.Kind.PropertyAssignment,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        name: {
+            kind: J.Kind.RightPadded,
+            element: {
+                kind: J.Kind.Identifier,
+                id: randomId(),
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                simpleName: key,
+                annotations: [],
+                type: undefined,
+            },
+            after: emptySpace,
+            markers: emptyMarkers,
+        },
+        assigmentToken: 'Colon',
+        initializer: {
+            kind: J.Kind.Literal,
+            id: randomId(),
+            prefix: singleSpace,
+            markers: emptyMarkers,
+            value: value,
+            valueSource: `'${value}'`,
+            unicodeEscapes: undefined,
+            type: undefined,
+        },
+    };
+}
+
+export function buildOptionsObject(properties: any[]): any {
+    return {
+        kind: J.Kind.NewClass,
+        id: randomId(),
+        prefix: emptySpace,
+        markers: emptyMarkers,
+        enclosing: undefined,
+        new: emptySpace,
+        clazz: undefined,
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [],
+        },
+        body: {
+            kind: J.Kind.Block,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            static: {kind: J.Kind.RightPadded, element: false, after: emptySpace, markers: emptyMarkers},
+            statements: properties.map(p => ({
+                kind: J.Kind.RightPadded,
+                element: p,
+                after: emptySpace,
+                markers: emptyMarkers,
+            })),
+            end: singleSpace,
+        },
+        constructorType: undefined,
+    };
+}
+
+export function identifier(simpleName: string, prefix = emptySpace): J.Identifier {
+    return {
+        kind: J.Kind.Identifier,
+        id: randomId(),
+        prefix,
+        markers: emptyMarkers,
+        simpleName,
+        annotations: [],
+        type: undefined,
+    } as J.Identifier;
+}
+
+export function rightPadded<T>(element: T, prefix = emptySpace): any {
+    return {kind: J.Kind.RightPadded, element, after: prefix, markers: emptyMarkers};
+}

package/src/migration/json-support.ts

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, randomId} from "@openrewrite/rewrite";
+import {getMemberKeyName, isMember, isObject, Json, rightPadded, space} from "@openrewrite/rewrite/json";
+
+export function isRootTsconfig(sourcePath: string): boolean {
+    return (sourcePath.split('/').pop() ?? '') === 'tsconfig.json';
+}
+
+/**
+ * `extends` replaces `angularCompilerOptions` wholesale rather than merging it, so a derived
+ * tsconfig that declares the block needs its own copy of every option set in the root.
+ */
+export function declaresAngularCompilerOptions(doc: Json.Document): boolean {
+    const root = doc.value;
+    return isObject(root) && findMemberIndex(root, 'angularCompilerOptions') !== -1;
+}
+
+export function literal(source: string, value: unknown): Json.Literal {
+    return {
+        kind: Json.Kind.Literal,
+        id: randomId(),
+        prefix: space(' '),
+        markers: emptyMarkers,
+        source,
+        value
+    };
+}
+
+export function buildMember(key: string, value: Json.Value, keyPrefix = ''): Json.Member {
+    return {
+        kind: Json.Kind.Member,
+        id: randomId(),
+        prefix: space(''),
+        markers: emptyMarkers,
+        key: rightPadded({
+            kind: Json.Kind.Literal,
+            id: randomId(),
+            prefix: space(keyPrefix),
+            markers: emptyMarkers,
+            source: `"${key}"`,
+            value: key
+        } as Json.Literal, space('')),
+        value
+    };
+}
+
+export function memberIndent(obj: Json.Object, fallback: string): string {
+    const first = obj.members.find(rp => isMember(rp.element));
+    if (!first) return fallback;
+    const firstPrefix = (first.element as Json.Member).key.element.prefix.whitespace;
+    const match = firstPrefix.match(/\n([ \t]+)/);
+    return match ? match[1] : fallback;
+}
+
+export function findMemberIndex(obj: Json.Object, key: string): number {
+    return obj.members.findIndex(rp => isMember(rp.element) && getMemberKeyName(rp.element as Json.Member) === key);
+}
+
+export function appendMember(obj: Json.Object, newMember: Json.Member, fallbackClosingWhitespace: string): Json.Object {
+    // An empty object holds a single Json.Empty placeholder rather than any members
+    const members = obj.members.filter(rp => isMember(rp.element));
+    const closing = members.length > 0
+        ? members[members.length - 1].after
+        : space(fallbackClosingWhitespace);
+
+    if (members.length > 0) {
+        members[members.length - 1] = {...members[members.length - 1], after: space('')};
+    }
+    members.push(rightPadded(newMember, closing));
+
+    return {...obj, members};
+}
+
+/** `indent` is the indentation of the member the returned value is assigned to. */
+function buildNestedValue(keys: string[], leaf: Json.Value, indent: string, indentUnit: string): Json.Value {
+    if (keys.length === 0) return leaf;
+
+    const childIndent = indent + indentUnit;
+    return {
+        kind: Json.Kind.Object,
+        id: randomId(),
+        prefix: space(' '),
+        markers: emptyMarkers,
+        members: [rightPadded(
+            buildMember(keys[0], buildNestedValue(keys.slice(1), leaf, childIndent, indentUnit), '\n' + childIndent),
+            space('\n' + indent))],
+    } as Json.Object;
+}
+
+/**
+ * Adds `leaf` at `keys`, creating missing intermediate objects. Returns `obj` unchanged when the
+ * path already exists, or when an intermediate key holds something other than an object.
+ * `indent` is the indentation of the members of `obj`.
+ */
+export function addMemberPath(obj: Json.Object, keys: string[], leaf: Json.Value, indent: string, indentUnit: string): Json.Object {
+    const index = findMemberIndex(obj, keys[0]);
+    if (index === -1) {
+        const newMember = buildMember(keys[0], buildNestedValue(keys.slice(1), leaf, indent, indentUnit), '\n' + indent);
+        return appendMember(obj, newMember, '\n' + indent.slice(0, Math.max(0, indent.length - indentUnit.length)));
+    }
+
+    if (keys.length === 1) return obj;
+
+    const member = obj.members[index].element as Json.Member;
+    if (!isObject(member.value)) return obj;
+
+    const child = member.value as Json.Object;
+    const updated = addMemberPath(child, keys.slice(1), leaf, memberIndent(child, indent + indentUnit), indentUnit);
+    if (updated === child) return obj;
+
+    const members = [...obj.members];
+    members[index] = {...members[index], element: {...member, value: updated} as Json.Member};
+    return {...obj, members};
+}

package/src/migration/migrate-input-to-signal.ts

@@ -8,6 +8,7 @@ import {ExecutionContext, randomId, emptyMarkers, markers as mkMarkers, Recipe,
 import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
 import {J, isIdentifier, isLiteral, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
 import {create} from "mutative";
+import {buildOptionsObject, buildPropertyAssignment} from "./js-support";
 
 const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe', 'Injectable'];
 
@@ -220,73 +221,6 @@ function buildInputCall(typeExpr: any, existingInitializer: any, config: InputCo
     return call;
 }
 
-function buildPropertyAssignment(key: string, value: string): any {
-    return {
-        kind: JS.Kind.PropertyAssignment,
-        id: randomId(),
-        prefix: singleSpace,
-        markers: emptyMarkers,
-        name: {
-            kind: J.Kind.RightPadded,
-            element: {
-                kind: J.Kind.Identifier,
-                id: randomId(),
-                prefix: emptySpace,
-                markers: emptyMarkers,
-                simpleName: key,
-                annotations: [],
-                type: undefined,
-            },
-            after: emptySpace,
-            markers: emptyMarkers,
-        },
-        assigmentToken: 'Colon',
-        initializer: {
-            kind: J.Kind.Literal,
-            id: randomId(),
-            prefix: singleSpace,
-            markers: emptyMarkers,
-            value: value,
-            valueSource: `'${value}'`,
-            unicodeEscapes: undefined,
-            type: undefined,
-        },
-    };
-}
-
-function buildOptionsObject(properties: any[]): any {
-    return {
-        kind: J.Kind.NewClass,
-        id: randomId(),
-        prefix: emptySpace,
-        markers: emptyMarkers,
-        enclosing: undefined,
-        new: emptySpace,
-        clazz: undefined,
-        arguments: {
-            kind: 'org.openrewrite.java.tree.JContainer',
-            before: emptySpace,
-            markers: emptyMarkers,
-            elements: [],
-        },
-        body: {
-            kind: J.Kind.Block,
-            id: randomId(),
-            prefix: emptySpace,
-            markers: emptyMarkers,
-            static: {kind: J.Kind.RightPadded, element: false, after: emptySpace, markers: emptyMarkers},
-            statements: properties.map(p => ({
-                kind: J.Kind.RightPadded,
-                element: p,
-                after: emptySpace,
-                markers: emptyMarkers,
-            })),
-            end: singleSpace,
-        },
-        constructorType: undefined,
-    };
-}
-
 function buildInputField(varDecl: J.VariableDeclarations, inputAnnotationIdx: number, config: InputConfig): any {
     const namedVar = varDecl.variables[0].element;
     const inputCall = buildInputCall(