jcoffey-dev
bd6a605d61
Takes the flat module count from 66 to 42, continuing what admin/ and
calendar/ started.
lib/mailbox/ archiveDate, emptyFolder, folderMove, labelTree,
mailboxName, mailboxRoute
lib/sieve/ sieve, sieveApply, sieveFolders
lib/input/ keyboard, swipe, touch, listSelection, dropUpload
lib/notify/ notify, webpush, webpushEnable
lib/sw/ swCache, swFacts, staleBuild
lib/text/ html, markdown, text, emlName
FOUR THINGS THE FILENAMES GET WRONG, each checked by reading the file
rather than trusting what it is called:
- appFolder is not a mailbox. It is the `ihasmail` folder in JMAP
*Files*, where the client keeps signature images and synced settings.
It stays flat.
- format holds no formatting of text. It re-exports the date and clock
formatters, so it belongs with dates/datetime, not with text/.
- preview is the file viewer deciding what it can show without
downloading, and source is where to point someone asking for this
instance's AGPL source. Neither is about text.
- notify is not Web Push. It is the tab title, the favicon badge and
the new-mail sound -- in-app notification, which is why it sits with
webpush rather than under sw/ with the service worker's own concerns.
threadScroll stays flat too: it decides where a conversation opens, which
is view state rather than a gesture, and input/ is honest only if
everything in it interprets something the reader did.
No behavior change. Almost every reference was on the @/ alias; eight
relative imports in files that did not move, or that moved away from a
sibling, needed rewriting by hand.
103 lines
3.7 KiB
TypeScript
103 lines
3.7 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import { foldersNeeded, hasDirectory, planUpload } from "@/lib/input/dropUpload";
|
|
|
|
/**
|
|
* Dropping a folder in, reduced to the two things the DataTransfer entry API
|
|
* gets wrong if you take it at face value.
|
|
*
|
|
* `readEntries` answers with *up to* some number of entries and signals the end
|
|
* of a directory with an empty array, so a single call quietly loses everything
|
|
* past the first batch — a real folder of a few hundred files would upload the
|
|
* first hundred and look like it had finished. And a directory tree that cycles
|
|
* has to stop somewhere the tab is still alive.
|
|
*/
|
|
|
|
const file = (name: string) => new File([name], name);
|
|
|
|
/** A directory whose contents arrive a batch at a time, as a real one does. */
|
|
const dir = (name: string, children: unknown[], batch = 2) => {
|
|
let at = 0;
|
|
return {
|
|
isFile: false,
|
|
isDirectory: true,
|
|
name,
|
|
createReader: () => ({
|
|
readEntries: (cb: (e: never[]) => void) => {
|
|
const slice = children.slice(at, at + batch);
|
|
at += slice.length;
|
|
cb(slice as never[]);
|
|
},
|
|
}),
|
|
};
|
|
};
|
|
|
|
const leaf = (name: string) => ({
|
|
isFile: true,
|
|
isDirectory: false,
|
|
name,
|
|
file: (cb: (f: File) => void) => cb(file(name)),
|
|
});
|
|
|
|
describe("walking a dropped folder", () => {
|
|
it("reads a directory across as many batches as it takes", async () => {
|
|
// Five children, two per readEntries call: a single read would find two.
|
|
const plan = await planUpload([dir("docs", ["a", "b", "c", "d", "e"].map(leaf))] as never[]);
|
|
expect(plan.map((p) => p.file.name)).toEqual(["a", "b", "c", "d", "e"]);
|
|
expect(plan.every((p) => p.path.join("/") === "docs")).toBe(true);
|
|
});
|
|
|
|
it("keeps the folder each file came from", async () => {
|
|
const plan = await planUpload([dir("outer", [leaf("top"), dir("inner", [leaf("deep")])])] as never[]);
|
|
expect(plan.map((p) => [p.path.join("/"), p.file.name])).toEqual([
|
|
["outer", "top"],
|
|
["outer/inner", "deep"],
|
|
]);
|
|
});
|
|
|
|
it("puts a loose file at the drop itself", async () => {
|
|
const plan = await planUpload([leaf("loose")] as never[]);
|
|
expect(plan).toEqual([expect.objectContaining({ path: [] })]);
|
|
});
|
|
|
|
it("stops rather than following a cycle for ever", async () => {
|
|
const loop: Record<string, unknown> = {};
|
|
Object.assign(loop, dir("loop", []));
|
|
(loop as { createReader: () => unknown }).createReader = () => ({
|
|
readEntries: (cb: (e: unknown[]) => void) => cb([loop]),
|
|
});
|
|
// Terminating at all is the assertion; the caps decide where. Both are set
|
|
// low so the test does not have to read twenty thousand phantom entries.
|
|
const plan = await planUpload([loop] as never[], { maxDepth: 4, maxEntries: 50 });
|
|
expect(plan).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("the folders a plan needs", () => {
|
|
it("lists parents before their children", () => {
|
|
const needed = foldersNeeded([
|
|
{ file: file("x"), path: ["a", "b", "c"] },
|
|
{ file: file("y"), path: ["a"] },
|
|
]);
|
|
expect(needed).toEqual([["a"], ["a", "b"], ["a", "b", "c"]]);
|
|
});
|
|
|
|
it("names each folder once, however many files are in it", () => {
|
|
const needed = foldersNeeded([
|
|
{ file: file("x"), path: ["a"] },
|
|
{ file: file("y"), path: ["a"] },
|
|
]);
|
|
expect(needed).toEqual([["a"]]);
|
|
});
|
|
|
|
it("asks for nothing when everything lands at the drop", () => {
|
|
expect(foldersNeeded([{ file: file("x"), path: [] }])).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe("spotting a folder in the drop", () => {
|
|
it("is true when any entry is a directory", () => {
|
|
expect(hasDirectory([leaf("a"), dir("d", [])] as never[])).toBe(true);
|
|
expect(hasDirectory([leaf("a")] as never[])).toBe(false);
|
|
});
|
|
});
|