compose [nfc]: Make variant of _ContentInput without the typing notifier

We'll use this for the edit-message compose box.

Done by making _ContentInput and _ContentInputState into abstract
classes, with subclasses implementing versions with and without the
typing-notifier logic.

Author: chrisbobbe

lib/widgets/compose_box.dart

@@ -394,24 +394,136 @@ class ComposeContentController extends ComposeController<ContentValidationError>
   }
 }
 
-class _ContentInput extends StatefulWidget {
-  const _ContentInput({
+abstract class _ContentInput extends StatefulWidget {
+  /// A content input that operates [PerAccountStore.typingNotifier]
+  /// to send the self-user's typing-status updates.
+  ///
+  /// The typing-status updates will be sent to [destination].
+  factory _ContentInput.withTypingNotifier({
+    required Narrow narrow,
+    required SendableNarrow destination,
+    required ComposeBoxController controller,
+    required String hintText,
+  }) => _ContentInputWithTypingNotifier._(
+    narrow: narrow,
+    destination: destination,
+    controller: controller,
+    hintText: hintText,
+  );
+
+  // We'll use this soon.
+  // ignore: unused_element
+  factory _ContentInput.noTypingNotifier({
+    required Narrow narrow,
+    required ComposeBoxController controller,
+    required String hintText,
+  }) => _ContentInputNoTypingNotifier._(
+    narrow: narrow,
+    controller: controller,
+    hintText: hintText,
+  );
+
+  const _ContentInput._({
     required this.narrow,
-    required this.destination,
     required this.controller,
     required this.hintText,
   });
 
   final Narrow narrow;
-  final SendableNarrow destination;
   final ComposeBoxController controller;
   final String hintText;
+}
+
+abstract class _ContentInputState<T extends _ContentInput> extends State<T> {
+  static double maxHeight(BuildContext context) {
+    final clampingTextScaler = MediaQuery.textScalerOf(context)
+      .clamp(maxScaleFactor: 1.5);
+    final scaledLineHeight = clampingTextScaler.scale(_fontSize) * _lineHeightRatio;
+
+    // Reserve space to fully show the first 7th lines and just partially
+    // clip the 8th line, where the height matches the spec at
+    //   https://www.figma.com/design/1JTNtYo9memgW7vV6d0ygq/Zulip-Mobile?node-id=3960-5147&node-type=text&m=dev
+    // > Maximum size of the compose box is suggested to be 178px. Which
+    // > has 7 fully visible lines of text
+    //
+    // The partial line hints that the content input is scrollable.
+    //
+    // Using the ambient TextScale means this works for different values of the
+    // system text-size setting. We clamp to a max scale factor to limit
+    // how tall the content input can get; that's to save room for the message
+    // list. The user can still scroll the input to see everything.
+    return _verticalPadding + 7.727 * scaledLineHeight;
+  }
+
+  static const _verticalPadding = 8.0;
+  static const _fontSize = 17.0;
+  static const _lineHeight = 22.0;
+  static const _lineHeightRatio = _lineHeight / _fontSize;
+
+  @override
+  Widget build(BuildContext context) {
+    final designVariables = DesignVariables.of(context);
+
+    return ComposeAutocomplete(
+      narrow: widget.narrow,
+      controller: widget.controller.content,
+      focusNode: widget.controller.contentFocusNode,
+      fieldViewBuilder: (context) => ConstrainedBox(
+        constraints: BoxConstraints(maxHeight: maxHeight(context)),
+        // This [ClipRect] replaces the [TextField] clipping we disable below.
+        child: ClipRect(
+          child: InsetShadowBox(
+            top: _verticalPadding, bottom: _verticalPadding,
+            color: designVariables.composeBoxBg,
+            child: TextField(
+              controller: widget.controller.content,
+              focusNode: widget.controller.contentFocusNode,
+              // Let the content show through the `contentPadding` so that
+              // our [InsetShadowBox] can fade it smoothly there.
+              clipBehavior: Clip.none,
+              style: TextStyle(
+                fontSize: _fontSize,
+                height: _lineHeightRatio,
+                color: designVariables.textInput),
+              // From the spec at
+              //   https://www.figma.com/design/1JTNtYo9memgW7vV6d0ygq/Zulip-Mobile?node-id=3960-5147&node-type=text&m=dev
+              // > Compose box has the height to fit 2 lines. This is [done] to
+              // > have a bigger hit area for the user to start the input. […]
+              minLines: 2,
+              maxLines: null,
+              textCapitalization: TextCapitalization.sentences,
+              decoration: InputDecoration(
+                // This padding ensures that the user can always scroll long
+                // content entirely out of the top or bottom shadow if desired.
+                // With this and the `minLines: 2` above, an empty content input
+                // gets 60px vertical distance (with no text-size scaling)
+                // between the top of the top shadow and the bottom of the
+                // bottom shadow. That's a bit more than the 54px given in the
+                // Figma, and we can revisit if needed, but it's tricky to get
+                // that 54px distance while also making the scrolling work like
+                // this and offering two lines of touchable area.
+                contentPadding: const EdgeInsets.symmetric(vertical: _verticalPadding),
+                hintText: widget.hintText,
+                hintStyle: TextStyle(
+                  color: designVariables.textInput.withFadedAlpha(0.5))))))));
+  }
+}
+
+class _ContentInputWithTypingNotifier extends _ContentInput {
+  const _ContentInputWithTypingNotifier._({
+    required super.narrow,
+    required this.destination,
+    required super.controller,
+    required super.hintText,
+  }) : super._();
+
+  final SendableNarrow destination;
 
   @override
-  State<_ContentInput> createState() => _ContentInputState();
+  State<_ContentInput> createState() => _ContentInputStateWithTypingNotifier();
 }
 
-class _ContentInputState extends State<_ContentInput> with WidgetsBindingObserver {
+class _ContentInputStateWithTypingNotifier extends _ContentInputState<_ContentInputWithTypingNotifier> with WidgetsBindingObserver {
   @override
   void initState() {
     super.initState();
@@ -421,7 +533,7 @@ class _ContentInputState extends State<_ContentInput> with WidgetsBindingObserve
   }
 
   @override
-  void didUpdateWidget(covariant _ContentInput oldWidget) {
+  void didUpdateWidget(covariant _ContentInputWithTypingNotifier oldWidget) {
     super.didUpdateWidget(oldWidget);
     if (widget.controller != oldWidget.controller) {
       oldWidget.controller.content.removeListener(_contentChanged);
@@ -483,81 +595,21 @@ class _ContentInputState extends State<_ContentInput> with WidgetsBindingObserve
       case AppLifecycleState.resumed:
     }
   }
+}
 
-  static double maxHeight(BuildContext context) {
-    final clampingTextScaler = MediaQuery.textScalerOf(context)
-      .clamp(maxScaleFactor: 1.5);
-    final scaledLineHeight = clampingTextScaler.scale(_fontSize) * _lineHeightRatio;
-
-    // Reserve space to fully show the first 7th lines and just partially
-    // clip the 8th line, where the height matches the spec at
-    //   https://www.figma.com/design/1JTNtYo9memgW7vV6d0ygq/Zulip-Mobile?node-id=3960-5147&node-type=text&m=dev
-    // > Maximum size of the compose box is suggested to be 178px. Which
-    // > has 7 fully visible lines of text
-    //
-    // The partial line hints that the content input is scrollable.
-    //
-    // Using the ambient TextScale means this works for different values of the
-    // system text-size setting. We clamp to a max scale factor to limit
-    // how tall the content input can get; that's to save room for the message
-    // list. The user can still scroll the input to see everything.
-    return _verticalPadding + 7.727 * scaledLineHeight;
-  }
-
-  static const _verticalPadding = 8.0;
-  static const _fontSize = 17.0;
-  static const _lineHeight = 22.0;
-  static const _lineHeightRatio = _lineHeight / _fontSize;
+class _ContentInputNoTypingNotifier extends _ContentInput {
+  const _ContentInputNoTypingNotifier._({
+    required super.narrow,
+    required super.controller,
+    required super.hintText,
+  }) : super._();
 
   @override
-  Widget build(BuildContext context) {
-    final designVariables = DesignVariables.of(context);
-
-    return ComposeAutocomplete(
-      narrow: widget.narrow,
-      controller: widget.controller.content,
-      focusNode: widget.controller.contentFocusNode,
-      fieldViewBuilder: (context) => ConstrainedBox(
-        constraints: BoxConstraints(maxHeight: maxHeight(context)),
-        // This [ClipRect] replaces the [TextField] clipping we disable below.
-        child: ClipRect(
-          child: InsetShadowBox(
-            top: _verticalPadding, bottom: _verticalPadding,
-            color: designVariables.composeBoxBg,
-            child: TextField(
-              controller: widget.controller.content,
-              focusNode: widget.controller.contentFocusNode,
-              // Let the content show through the `contentPadding` so that
-              // our [InsetShadowBox] can fade it smoothly there.
-              clipBehavior: Clip.none,
-              style: TextStyle(
-                fontSize: _fontSize,
-                height: _lineHeightRatio,
-                color: designVariables.textInput),
-              // From the spec at
-              //   https://www.figma.com/design/1JTNtYo9memgW7vV6d0ygq/Zulip-Mobile?node-id=3960-5147&node-type=text&m=dev
-              // > Compose box has the height to fit 2 lines. This is [done] to
-              // > have a bigger hit area for the user to start the input. […]
-              minLines: 2,
-              maxLines: null,
-              textCapitalization: TextCapitalization.sentences,
-              decoration: InputDecoration(
-                // This padding ensures that the user can always scroll long
-                // content entirely out of the top or bottom shadow if desired.
-                // With this and the `minLines: 2` above, an empty content input
-                // gets 60px vertical distance (with no text-size scaling)
-                // between the top of the top shadow and the bottom of the
-                // bottom shadow. That's a bit more than the 54px given in the
-                // Figma, and we can revisit if needed, but it's tricky to get
-                // that 54px distance while also making the scrolling work like
-                // this and offering two lines of touchable area.
-                contentPadding: const EdgeInsets.symmetric(vertical: _verticalPadding),
-                hintText: widget.hintText,
-                hintStyle: TextStyle(
-                  color: designVariables.textInput.withFadedAlpha(0.5))))))));
-  }
+  State<_ContentInput> createState() => _ContentInputStateNoTypingNotifier();
 }
 
+class _ContentInputStateNoTypingNotifier extends _ContentInputState<_ContentInputNoTypingNotifier> {}
+
 /// The content input for _StreamComposeBox.
 class _StreamContentInput extends StatefulWidget {
   const _StreamContentInput({required this.narrow, required this.controller});
@@ -645,7 +697,7 @@ class _StreamContentInputState extends State<_StreamContentInput> {
       // ignore: dead_null_aware_expression // null topic names soon to be enabled
       : '#$streamName > ${hintTopic.displayName ?? store.realmEmptyTopicDisplayName}';
 
-    return _ContentInput(
+    return _ContentInput.withTypingNotifier(
       narrow: widget.narrow,
       destination: TopicNarrow(widget.narrow.streamId,
         TopicName(widget.controller.topic.textNormalized)),
@@ -732,7 +784,7 @@ class _FixedDestinationContentInput extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return _ContentInput(
+    return _ContentInput.withTypingNotifier(
       narrow: narrow,
       destination: narrow,
       controller: controller,