Names quak builds from server data fit in 255 bytes (closes #205)

The default names of `quak get`, `quak get-thumb`, `downloadFile` and `downloadThumbnail`, and the album folders of `backup-metadata`, could be over 255 bytes, which a file system refuses. `defaultFileName` and `shortenKeepingExtension` in `src/filename.ts` now cut such a name short, keeping its extension when it fits; a live photo's image and video get their own extension before the cut. A cut name never starts with a dot and is never a Windows device name. `--out` and `outPath` are kept as given. A `backup-metadata` folder keeps its `<id>-`. `safeExtension` gives `.bin` for an extension of more than 16 letters and digits, so a save path's name always fits.

Model: opus-5-5

test/filename/filename.test.ts

@@ -15,8 +15,10 @@
 import { describe, expect, it } from "vitest";
 
 import {
+    defaultFileName,
     safeExtension,
     sanitizeFileName,
+    shortenKeepingExtension,
     shortenToBytes,
 } from "../../src/filename.js";
 
@@ -94,6 +96,12 @@ describe("safeExtension", () => {
         expect(safeExtension("x.jp g")).toBe(".bin");
         expect(safeExtension("x.jpg\0")).toBe(".bin");
     });
+
+    it("keeps an extension of 16 letters and digits, and uses .bin for a longer one", () => {
+        expect(safeExtension(`x.${"e".repeat(16)}`)).toBe(`.${"e".repeat(16)}`);
+        expect(safeExtension(`x.${"e".repeat(17)}`)).toBe(".bin");
+        expect(safeExtension(`b.${"e".repeat(300)}`)).toBe(".bin");
+    });
 });
 
 describe("shortenToBytes", () => {
@@ -118,3 +126,103 @@ describe("shortenToBytes", () => {
         );
     });
 });
+
+describe("shortenKeepingExtension", () => {
+    it("returns a name that fits unchanged", () => {
+        expect(shortenKeepingExtension("beach.jpg", 9)).toBe("beach.jpg");
+        expect(shortenKeepingExtension("beach", 5)).toBe("beach");
+    });
+
+    it("cuts the part before the extension short and keeps the extension", () => {
+        expect(shortenKeepingExtension(`${"t".repeat(296)}.jpg`, 255)).toBe(
+            `${"t".repeat(251)}.jpg`,
+        );
+        expect(shortenKeepingExtension("é".repeat(150), 255)).toBe(
+            "é".repeat(127),
+        );
+    });
+
+    // A name cut down to its extension would start with a dot, and so be
+    // hidden.
+    it("keeps the first character before the extension, cutting the extension short to leave room for it", () => {
+        expect(shortenKeepingExtension(`b.${"e".repeat(300)}`, 255)).toBe(
+            `b.${"e".repeat(253)}`,
+        );
+        expect(shortenKeepingExtension(`ab.${"e".repeat(300)}`, 255)).toBe(
+            `a.${"e".repeat(253)}`,
+        );
+        expect(shortenKeepingExtension(`é.${"e".repeat(300)}`, 255)).toBe(
+            `é.${"e".repeat(252)}`,
+        );
+        // "€" takes three bytes, so the extension is cut to 253 and the
+        // part before it keeps the two bytes left over, for the "a".
+        expect(shortenKeepingExtension(`a.${"€".repeat(90)}`, 255)).toBe(
+            `a.${"€".repeat(84)}`,
+        );
+    });
+
+    it("puts `insert` right before the extension and leaves room for it", () => {
+        expect(shortenKeepingExtension("beach.jpg", 255, " (7)")).toBe(
+            "beach (7).jpg",
+        );
+        expect(
+            shortenKeepingExtension(`${"t".repeat(296)}.jpg`, 255, " (7)"),
+        ).toBe(`${"t".repeat(247)} (7).jpg`);
+        expect(
+            shortenKeepingExtension(`b.${"e".repeat(300)}`, 255, " (7)"),
+        ).toBe(`b (7).${"e".repeat(249)}`);
+    });
+});
+
+describe("defaultFileName", () => {
+    it("is the title when it is safe and fits", () => {
+        expect(defaultFileName("IMG_0001.HEIC", 42)).toBe("IMG_0001.HEIC");
+    });
+
+    it("replaces unsafe characters, and is file-<id> for an empty title", () => {
+        expect(defaultFileName("../x.jpg", 42)).toBe("__x.jpg");
+        expect(defaultFileName("", 42)).toBe("file-42");
+    });
+
+    it("cuts a title over 255 bytes short, keeping its extension", () => {
+        expect(defaultFileName(`${"t".repeat(296)}.jpg`, 42)).toBe(
+            `${"t".repeat(251)}.jpg`,
+        );
+        expect(defaultFileName(`b.${"e".repeat(300)}`, 42)).toBe(
+            `b.${"e".repeat(253)}`,
+        );
+    });
+
+    it("puts `prefix` before the title and leaves room for it", () => {
+        expect(defaultFileName("beach.jpg", 42, { prefix: "thumb_" })).toBe(
+            "thumb_beach.jpg",
+        );
+        expect(
+            defaultFileName(`${"t".repeat(296)}.jpg`, 42, { prefix: "thumb_" }),
+        ).toBe(`thumb_${"t".repeat(245)}.jpg`);
+    });
+
+    // A live photo's image and video are each named with their own
+    // extension, and the name is cut short once that extension is in it.
+    it("puts `ext` in place of the title's extension before cutting the name short", () => {
+        expect(defaultFileName("IMG_0001.HEIC", 42, { ext: ".mov" })).toBe(
+            "IMG_0001.mov",
+        );
+        expect(defaultFileName("", 42, { ext: ".mov" })).toBe("file-42.mov");
+        expect(
+            defaultFileName(`${"t".repeat(251)}.jpg`, 42, { ext: ".heic" }),
+        ).toBe(`${"t".repeat(250)}.heic`);
+        expect(defaultFileName("t".repeat(300), 42, { ext: ".heic" })).toBe(
+            `${"t".repeat(250)}.heic`,
+        );
+    });
+
+    // Cutting `CONSOLE` or `NULL` short before a long extension leaves `CON`
+    // or `NUL`, so the name gets the `_` `sanitizeFileName` gives a device
+    // name, and the part before the extension gives up a byte for it.
+    it("never returns a Windows device name, even once cut short", () => {
+        const ext = `.${"e".repeat(251)}`;
+        expect(defaultFileName(`CONSOLE${ext}`, 42)).toBe(`_CO${ext}`);
+        expect(defaultFileName(`NULL${ext}`, 42)).toBe(`_NU${ext}`);
+    });
+});