import { file, readableStreamToArrayBuffer, readableStreamToArray, readableStreamToText } from "bun";
import { expect, it, beforeEach, afterEach, describe } from "bun:test";
import { mkfifo } from "mkfifo";
import { unlinkSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { gc } from "./gc";

beforeEach(() => gc());
afterEach(() => gc());

describe("WritableStream", () => {
  it("works", async () => {
    try {
      var chunks = [];
      var writable = new WritableStream({
        write(chunk, controller) {
          chunks.push(chunk);
        },
        close(er) {
          console.log("closed");
          console.log(er);
        },
        abort(reason) {
          console.log("aborted!");
          console.log(reason);
        },
      });

      var writer = writable.getWriter();

      writer.write(new Uint8Array([1, 2, 3]));

      writer.write(new Uint8Array([4, 5, 6]));

      await writer.close();

      expect(JSON.stringify(Array.from(Buffer.concat(chunks)))).toBe(JSON.stringify([1, 2, 3, 4, 5, 6]));
    } catch (e) {
      console.log(e);
      console.log(e.stack);
      throw e;
    }
  });

  it("pipeTo", async () => {
    const rs = new ReadableStream({
      start(controller) {
        controller.enqueue("hello world");
        controller.close();
      },
    });

    let received;
    const ws = new WritableStream({
      write(chunk, controller) {
        received = chunk;
      },
    });
    await rs.pipeTo(ws);
    expect(received).toBe("hello world");
  });
});

describe("ReadableStream.prototype.tee", () => {
  it("class", () => {
    const [a, b] = new ReadableStream().tee();
    expect(a instanceof ReadableStream).toBe(true);
    expect(b instanceof ReadableStream).toBe(true);
  });

  describe("default stream", () => {
    it("works", async () => {
      var [a, b] = new ReadableStream({
        start(controller) {
          controller.enqueue("a");
          controller.enqueue("b");
          controller.enqueue("c");
          controller.close();
        },
      }).tee();

      expect(await readableStreamToText(a)).toBe("abc");
      expect(await readableStreamToText(b)).toBe("abc");
    });
  });

  describe("direct stream", () => {
    it("works", async () => {
      try {
        var [a, b] = new ReadableStream({
          pull(controller) {
            controller.write("a");
            controller.write("b");
            controller.write("c");
            controller.close();
          },
          type: "direct",
        }).tee();

        expect(await readableStreamToText(a)).toBe("abc");
        expect(await readableStreamToText(b)).toBe("abc");
      } catch (e) {
        console.log(e.message);
        console.log(e.stack);
        throw e;
      }
    });
  });
});

it("ReadableStream.prototype[Symbol.asyncIterator]", async () => {
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
    cancel(reason) {},
  });

  const chunks = [];
  try {
    for await (const chunk of stream) {
      chunks.push(chunk);
    }
  } catch (e) {
    console.log(e.message);
    console.log(e.stack);
  }

  expect(chunks.join("")).toBe("helloworld");
});

it("ReadableStream.prototype[Symbol.asyncIterator] pull", async () => {
  const stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
    cancel(reason) {},
  });

  const chunks = [];
  for await (const chunk of stream) {
    chunks.push(chunk);
  }
  expect(chunks.join("")).toBe("helloworld");
});

it("ReadableStream.prototype[Symbol.asyncIterator] direct", async () => {
  const stream = new ReadableStream({
    pull(controller) {
      controller.write("hello");
      controller.write("world");
      controller.close();
    },
    type: "direct",
    cancel(reason) {},
  });

  const chunks = [];
  try {
    for await (const chunk of stream) {
      chunks.push(chunk);
    }
  } catch (e) {
    console.log(e.message);
    console.log(e.stack);
  }

  expect(Buffer.concat(chunks).toString()).toBe("helloworld");
});

it("ReadableStream.prototype.values() cancel", async () => {
  var cancelled = false;
  const stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
    },
    cancel(reason) {
      cancelled = true;
    },
  });

  for await (const chunk of stream.values({ preventCancel: false })) {
    break;
  }
  expect(cancelled).toBe(true);
});

it("ReadableStream.prototype.values() preventCancel", async () => {
  var cancelled = false;
  const stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
    },
    cancel(reason) {
      cancelled = true;
    },
  });

  for await (const chunk of stream.values({ preventCancel: true })) {
    break;
  }
  expect(cancelled).toBe(false);
});

it("ReadableStream.prototype.values", async () => {
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
  });

  const chunks = [];
  for await (const chunk of stream.values()) {
    chunks.push(chunk);
  }
  expect(chunks.join("")).toBe("helloworld");
});

it("Bun.file() read text from pipe", async () => {
  try {
    unlinkSync("/tmp/fifo");
  } catch (e) {}

  console.log("here");
  mkfifo("/tmp/fifo", 0o666);

  // 65k so its less than the max on linux
  const large = "HELLO!".repeat((((1024 * 65) / "HELLO!".length) | 0) + 1);

  const chunks = [];

  const proc = Bun.spawn({
    cmd: ["bash", join(import.meta.dir + "/", "bun-streams-test-fifo.sh"), "/tmp/fifo"],
    stderr: "inherit",
    stdout: null,
    stdin: null,
    env: {
      FIFO_TEST: large,
    },
  });
  const exited = proc.exited;
  proc.ref();

  const prom = (async function () {
    while (chunks.length === 0) {
      var out = Bun.file("/tmp/fifo").stream();
      for await (const chunk of out) {
        chunks.push(chunk);
      }
    }
    return Buffer.concat(chunks).toString();
  })();

  const [status, output] = await Promise.all([exited, prom]);
  expect(output.length).toBe(large.length + 1);
  expect(output).toBe(large + "\n");
  expect(status).toBe(0);
});

it("exists globally", () => {
  expect(typeof ReadableStream).toBe("function");
  expect(typeof ReadableStreamBYOBReader).toBe("function");
  expect(typeof ReadableStreamBYOBRequest).toBe("function");
  expect(typeof ReadableStreamDefaultController).toBe("function");
  expect(typeof ReadableStreamDefaultReader).toBe("function");
  expect(typeof TransformStream).toBe("function");
  expect(typeof TransformStreamDefaultController).toBe("function");
  expect(typeof WritableStream).toBe("function");
  expect(typeof WritableStreamDefaultController).toBe("function");
  expect(typeof WritableStreamDefaultWriter).toBe("function");
  expect(typeof ByteLengthQueuingStrategy).toBe("function");
  expect(typeof CountQueuingStrategy).toBe("function");
});

it("new Response(stream).body", async () => {
  var stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
    cancel() {},
  });
  var response = new Response(stream);
  expect(response.body).toBe(stream);
  expect(await response.text()).toBe("helloworld");
});

it("new Request({body: stream}).body", async () => {
  var stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
    cancel() {},
  });
  var response = new Request({ body: stream });
  expect(response.body).toBe(stream);
  expect(await response.text()).toBe("helloworld");
});

it("ReadableStream (readMany)", async () => {
  var stream = new ReadableStream({
    pull(controller) {
      controller.enqueue("hello");
      controller.enqueue("world");
      controller.close();
    },
    cancel() {},
  });
  var reader = stream.getReader();
  const chunk = await reader.readMany();
  expect(chunk.value.join("")).toBe("helloworld");
  expect((await reader.read()).done).toBe(true);
});

it("ReadableStream (direct)", async () => {
  var stream = new ReadableStream({
    pull(controller) {
      controller.write("hello");
      controller.write("world");
      controller.close();
    },
    cancel() {},
    type: "direct",
  });
  var reader = stream.getReader();
  const chunk = await reader.read();
  expect(chunk.value.join("")).toBe(Buffer.from("helloworld").join(""));
  expect((await reader.read()).done).toBe(true);
  expect((await reader.read()).done).toBe(true);
});

it("ReadableStream (bytes)", async () => {
  var stream = new ReadableStream({
    start(controller) {
      controller.enqueue(Buffer.from("abdefgh"));
    },
    pull(controller) {},
    cancel() {},
    type: "bytes",
  });
  const chunks = [];
  const chunk = await stream.getReader().read();
  chunks.push(chunk.value);
  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
});

it("ReadableStream (default)", async () => {
  var stream = new ReadableStream({
    start(controller) {
      controller.enqueue(Buffer.from("abdefgh"));
      controller.close();
    },
    pull(controller) {},
    cancel() {},
  });
  const chunks = [];
  const chunk = await stream.getReader().read();
  chunks.push(chunk.value);
  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
});

it("readableStreamToArray", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
    type: "bytes",
  });

  const chunks = await readableStreamToArray(stream);

  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
});

it("readableStreamToArrayBuffer (bytes)", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
    type: "bytes",
  });
  const buffer = await readableStreamToArrayBuffer(stream);
  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
});

it("readableStreamToArrayBuffer (default)", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
  });

  const buffer = await readableStreamToArrayBuffer(stream);
  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
});

it("ReadableStream for Blob", async () => {
  var blob = new Blob(["abdefgh", "ijklmnop"]);
  expect(await blob.text()).toBe("abdefghijklmnop");
  var stream;
  try {
    stream = blob.stream();
    stream = blob.stream();
  } catch (e) {
    console.error(e);
    console.error(e.stack);
  }
  const chunks = [];
  var reader;
  reader = stream.getReader();

  while (true) {
    var chunk;
    try {
      chunk = await reader.read();
    } catch (e) {
      console.error(e);
      console.error(e.stack);
    }
    if (chunk.done) break;
    chunks.push(new TextDecoder().decode(chunk.value));
  }
  expect(chunks.join("")).toBe(new TextDecoder().decode(Buffer.from("abdefghijklmnop")));
});

it("ReadableStream for File", async () => {
  var blob = file(import.meta.dir + "/fetch.js.txt");
  var stream = blob.stream();
  const chunks = [];
  var reader = stream.getReader();
  stream = undefined;
  while (true) {
    const chunk = await reader.read();
    if (chunk.done) break;
    chunks.push(chunk.value);
  }
  reader = undefined;
  const output = new Uint8Array(await blob.arrayBuffer()).join("");
  const input = chunks.map(a => a.join("")).join("");
  expect(output).toBe(input);
});

it("ReadableStream for File errors", async () => {
  try {
    var blob = file(import.meta.dir + "/fetch.js.txt.notfound");
    blob.stream().getReader();
    throw new Error("should not reach here");
  } catch (e) {
    expect(e.code).toBe("ENOENT");
    expect(e.syscall).toBe("open");
  }
});

it("ReadableStream for empty blob closes immediately", async () => {
  var blob = new Blob([]);
  var stream = blob.stream();
  const chunks = [];
  var reader = stream.getReader();
  while (true) {
    const chunk = await reader.read();
    if (chunk.done) break;
    chunks.push(chunk.value);
  }

  expect(chunks.length).toBe(0);
});

it("ReadableStream for empty file closes immediately", async () => {
  writeFileSync("/tmp/bun-empty-file-123456", "");
  var blob = file("/tmp/bun-empty-file-123456");
  var stream;
  try {
    stream = blob.stream();
  } catch (e) {
    console.error(e.stack);
  }
  const chunks = [];
  var reader = stream.getReader();
  while (true) {
    const chunk = await reader.read();
    if (chunk.done) break;
    chunks.push(chunk.value);
  }

  expect(chunks.length).toBe(0);
});

it("new Response(stream).arrayBuffer() (bytes)", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
    type: "bytes",
  });
  const buffer = await new Response(stream).arrayBuffer();
  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
});

it("new Response(stream).arrayBuffer() (default)", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
  });
  const buffer = await new Response(stream).arrayBuffer();
  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
});

it("new Response(stream).text() (default)", async () => {
  var queue = [Buffer.from("abdefgh")];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
  });
  const text = await new Response(stream).text();
  expect(text).toBe("abdefgh");
});

it("new Response(stream).json() (default)", async () => {
  var queue = [Buffer.from(JSON.stringify({ hello: true }))];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
  });
  const json = await new Response(stream).json();
  expect(json.hello).toBe(true);
});

it("new Response(stream).blob() (default)", async () => {
  var queue = [Buffer.from(JSON.stringify({ hello: true }))];
  var stream = new ReadableStream({
    pull(controller) {
      var chunk = queue.shift();
      if (chunk) {
        controller.enqueue(chunk);
      } else {
        controller.close();
      }
    },
    cancel() {},
  });
  const response = new Response(stream);
  const blob = await response.blob();
  expect(await blob.text()).toBe('{"hello":true}');
});

it("Blob.stream() -> new Response(stream).text()", async () => {
  var blob = new Blob(["abdefgh"]);
  var stream = blob.stream();
  const text = await new Response(stream).text();
  expect(text).toBe("abdefgh");
});
eck warning.


</td></tr>
<tr class='logheader'><td><span title='2023-03-18 21:36:42 +0300'>2023-03-18</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/test/configcontainer.cpp?h=r2.31.1&amp;id=00aa491ca0616e3a16474d548bea5ca274b6ab7d&amp;follow=1'>Use proper Catch2 macros to test for true/false</a></td><td><img src='//www.gravatar.com/avatar/7cf94c7218b74a36b40b1241e5c6649f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Alexander Batischev
</td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
This fixes a cppcheck warning.


</td></tr>
<tr class='logheader'><td><span title='2023-03-18 20:51:27 +0300'>2023-03-18</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/tr.po?h=r2.31.1&amp;id=536c7cd6610a38897c8d1008eb09009063e29f4d&amp;follow=1'>tr.po: remove old translation</a></td><td><img src='//www.gravatar.com/avatar/7cf94c7218b74a36b40b1241e5c6649f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Alexander Batischev
</td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
It wasn't removed when updating the file. See
https://github.com/newsboat/newsboat/pull/2377#discussion_r1140978931


</td></tr>
<tr class='logheader'><td><span title='2023-03-18 09:34:45 +0000'>2023-03-18</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/Cargo.lock?h=r2.31.1&amp;id=abbd99562ffeb6a35ee2825abdd416a20e08e8ed&amp;follow=1'>Chore(deps): bump libc from 0.2.139 to 0.2.140</a></td><td><img src='//www.gravatar.com/avatar/48ea49be76d0c68403a7f3df87e3487d?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> dependabot[bot]
</td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
Bumps [libc](https://github.com/rust-lang/libc) from 0.2.139 to 0.2.140.
- [Release notes](https://github.com/rust-lang/libc/releases)
- [Commits](https://github.com/rust-lang/libc/compare/0.2.139...0.2.140)

---
updated-dependencies:
- dependency-name: libc
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;

</td></tr>
<tr class='logheader'><td><span title='2023-03-17 08:19:06 +0100'>2023-03-17</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/it.po?h=r2.31.1&amp;id=e00a5f3230fb6140a263cfe5ceebfaf3b4a869b9&amp;follow=1'>Update Italian translation</a></td><td><img src='//www.gravatar.com/avatar/b882a1ce3f31801f3b45a1e8ccc38e30?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Mauro Scomparin
</td><td>1</td><td><span class='deletions'>-5</span>/<span class='insertions'>+6</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
Translated changed and added strings


</td></tr>
<tr class='logheader'><td><span title='2023-03-16 21:55:44 +0100'>2023-03-16</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/pl.po?h=r2.31.1&amp;id=92eba668d58a66ff7ac973eb1d088678db851184&amp;follow=1'>chore(l10n): Update Polish translation</a></td><td><img src='//www.gravatar.com/avatar/b665a4b6f301c000fd3bebf20b93cdde?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Carno
</td><td>1</td><td><span class='deletions'>-5</span>/<span class='insertions'>+5</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
Ref: https://github.com/newsboat/newsboat/pull/2371#issuecomment-1470827042


</td></tr>
<tr class='logheader'><td><span title='2023-03-16 19:13:09 +0100'>2023-03-16</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/nl.po?h=r2.31.1&amp;id=9f38e78ac2bd22210de2df8dadac9a7c0cc734ac&amp;follow=1'>Update Dutch translation</a></td><td><img src='//www.gravatar.com/avatar/478090ad868b9ff33a9824edbf79cd0e?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Dennis van der Schagt
</td><td>1</td><td><span class='deletions'>-6</span>/<span class='insertions'>+8</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
</td></tr>
<tr class='logheader'><td><span title='2023-03-16 13:25:56 +0300'>2023-03-16</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/tr.po?h=r2.31.1&amp;id=f74e6cae47f9d82d3730020408f8bfd2d93c7d1c&amp;follow=1'>Update Turkish translations</a></td><td><img src='//www.gravatar.com/avatar/430c946475b9a5959834279177c36d65?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Emir SARI
</td><td>1</td><td><span class='deletions'>-6</span>/<span class='insertions'>+6</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
</td></tr>
<tr class='logheader'><td><span title='2023-03-16 06:57:15 +0000'>2023-03-16</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/rust/regex-rs/Cargo.toml?h=r2.31.1&amp;id=e72e41b5c724669ff6c52266bb895e61304d0e05&amp;follow=1'>Chore(deps): bump bitflags from 1.3.2 to 2.0.1</a></td><td><img src='//www.gravatar.com/avatar/48ea49be76d0c68403a7f3df87e3487d?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> dependabot[bot]
</td><td>2</td><td><span class='deletions'>-5</span>/<span class='insertions'>+11</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
Bumps [bitflags](https://github.com/bitflags/bitflags) from 1.3.2 to 2.0.1.
- [Release notes](https://github.com/bitflags/bitflags/releases)
- [Changelog](https://github.com/bitflags/bitflags/blob/main/CHANGELOG.md)
- [Commits](https://github.com/bitflags/bitflags/compare/1.3.2...2.0.1)

---
updated-dependencies:
- dependency-name: bitflags
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;

</td></tr>
<tr class='logheader'><td><span title='2023-03-15 22:40:17 +0100'>2023-03-15</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/stfl/selecttag.stfl?h=r2.31.1&amp;id=62d547b671ed0c3f60967766c9d74adc5e162fa6&amp;follow=1'>Fix keybinds not working outside feedlist (#2358)</a></td><td><img src='//www.gravatar.com/avatar/7cf94c7218b74a36b40b1241e5c6649f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Alexander Batischev
</td><td>17</td><td><span class='deletions'>-16</span>/<span class='insertions'>+69</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
* Fix keybinds not working outside feedlist

This patch makes it so by default, the main "input widget" of a form is
focused, or the entire form is focused if there's no input widget (as is
the case in e.g. the help dialog).

Fixes #2351.

* Remove obselete quoting for STFL

The quoting was previously needed because we were directly including the
text in an STFL form specification.
This is no longer necessary now that we use the `stfl_set()` call.

* Focus form's "main" widget after exiting QnA

This fixes a problem with 4498a054f3a0211cf66e6940ad27babcfd0d167e that
was discovered by Dennis van der Schagt: the original issue still
occurred when the user exited the command line. This is caused by
`FormAction` attempting to focus "feeds" widget; in feedlist, this works
fine, but in other dialogs there is no such widget, so STFL focuses
"qnainput" instead, which then consumed all future inputs.

This commit fixes the problem by teaching each `FormAction` about its
main widget's name, so it knows what to focus upon finishing QnA.

Fixes #2351.

* *Always* focus form's "main widget" after QnA

This commit essentially reworks e487c02fea794b11456acc353b029fbb380ff0ad
with ideas from b1028db4a9eaf3215b99c7b725555e6b2544fd24: instead of
remembering which widget was focused before QnA, Newsboat just always
focuses the "main" one.

This work is by Dennis van der Schagt, I'm only committing it :)

Fixes #2351.

* Fix file browser's main widget name

---------

Co-authored-by: Dennis van der Schagt &lt;dennisschagt@gmail.com&gt;

</td></tr>
<tr class='logheader'><td><span title='2023-03-15 22:31:23 +0100'>2023-03-15</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/de.po?h=r2.31.1&amp;id=f971fac12b2e12870b33e6919f61dd18220dc6cd&amp;follow=1'>Update German translations</a></td><td><img src='//www.gravatar.com/avatar/30c3ee8fb1a5cbd66eb77f4d66e43a44?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Lysander Trischler
</td><td>1</td><td><span class='deletions'>-52</span>/<span class='insertions'>+52</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
The German language allows short list items to start in lower or
uppercase. I could not figure out if any version is slightly preferred
over the other. Most of the keymap entries were using lowercase,
however, some also started in uppercase (not counting for nouns which
are always capitalized). As the original English descriptions also use
uppercase I decided to switch to uppercase in order to help avoiding
mixed styles in the future for new keymap entries.

Also, I noticed that two different forms for "previous" ("vorherig" and
"vorhergehend") had been used, so I normalized them all to the shorter
version.

Finally, there was a typo in "als" where the "l" was missing. I'm only
mentioning this to avoid potential confusion with the review by any
non-German reviewers.


</td></tr>
<tr class='logheader'><td><span title='2023-03-15 23:31:37 +0300'>2023-03-15</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/docker/ubuntu_22.04-build-tools.dockerfile?h=r2.31.1&amp;id=34efc01fe7eb65cd492084129de2727744531add&amp;follow=1'>CI: bump Rust to 1.68.0</a></td><td><img src='//www.gravatar.com/avatar/7cf94c7218b74a36b40b1241e5c6649f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Alexander Batischev
</td><td>4</td><td><span class='deletions'>-10</span>/<span class='insertions'>+10</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
</td></tr>
<tr class='logheader'><td><span title='2023-03-15 23:29:34 +0300'>2023-03-15</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/po/zh_TW.po?h=r2.31.1&amp;id=ae1dfd6541c6d3906a2ff25dc24760dbdaa058cf&amp;follow=1'>Update .pot and .po files</a></td><td><img src='//www.gravatar.com/avatar/7cf94c7218b74a36b40b1241e5c6649f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Alexander Batischev
</td><td>19</td><td><span class='deletions'>-3707</span>/<span class='insertions'>+3997</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
</td></tr>
<tr class='logheader'><td><span title='2023-03-13 06:57:16 +0000'>2023-03-13</span></td><td class='logsubject'><a href='/ansg191/newsboat/commit/Cargo.lock?h=r2.31.1&amp;id=b4bee3f37ff558cae763796de0f6b0213c542fa4&amp;follow=1'>Chore(deps): bump chrono from 0.4.23 to 0.4.24</a></td><td><img src='//www.gravatar.com/avatar/48ea49be76d0c68403a7f3df87e3487d?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> dependabot[bot]
</td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr class='nohover-highlight'><td/><td colspan='5' class='logmsg'>
Bumps [chrono](https://github.com/chronotope/chrono) from 0.4.23 to 0.4.24.
- [Release notes](https://github.com/chronotope/chrono/releases)
- [Changelog](https://github.com/chronotope/chrono/blob/main/CHANGELOG.md)
- [Commits](https://github.com/chronotope/chrono/compare/v0.4.23...v0.4.24)

---
updated-dependencies:
- dependency-name: chrono
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] &lt;support@github.com&gt;

</td></tr>