@gjermundgaraba-designs/pixel-paper 0.20.0 → 0.21.0

package/src/commandPalette/commandPalette.ts

@@ -329,7 +329,7 @@ type ShownList = Readonly<{
   shownShift: number;
 }>;
 
-const isListedIn = (rows: ReadonlyArray<ShownRow>, rowId: string): boolean =>
+const isListed = (rows: ReadonlyArray<Readonly<{ id: string }>>, rowId: string): boolean =>
   Array.some(rows, (row) => row.id === rowId);
 
 // NOTE: where the cursor is among the rows a key carries (see `Model`). With no arrows waiting
@@ -339,16 +339,16 @@ const isListedIn = (rows: ReadonlyArray<ShownRow>, rowId: string): boolean =>
 // key waits for the next render.
 const cursorAsShown = (model: Model, shown: ShownList): Option.Option<Option.Option<string>> => {
   const { rows, maybeShownCursor, shownQuery, shownShift } = shown;
-  const isListed = shownQuery === query(model);
+  const isTheList = shownQuery === query(model);
 
-  if (isListed && model.cursorShift === 0) {
+  if (isTheList && model.cursorShift === 0) {
     return Option.some(
       Option.orElse(
-        Option.filter(maybeCurrentCursor(model), (rowId) => isListedIn(rows, rowId)),
+        Option.filter(maybeCurrentCursor(model), (rowId) => isListed(rows, rowId)),
         () => maybeShownCursor,
       ),
     );
-  } else if (isListed && shownShift === model.cursorShift) {
+  } else if (isTheList && shownShift === model.cursorShift) {
     return Option.some(maybeShownCursor);
   } else {
     return Option.none();
@@ -583,9 +583,6 @@ const pageOf = (commands: ReadonlyArray<Command>, state: OpenPage): Option.Optio
     Option.map((page) => ({ commandId: state.commandId, page, state })),
   );
 
-const isListed = (rows: ReadonlyArray<Choice | Command>, rowId: string): boolean =>
-  Array.some(rows, (row) => row.id === rowId);
-
 const firstListed = (
   rows: ReadonlyArray<Choice>,
   candidates: ReadonlyArray<Option.Option<string>>,
@@ -633,13 +630,11 @@ const unshiftedOf = (model: Model, commands: ReadonlyArray<Command>): Shown => {
       };
     },
     onSome: ({ page, state }) => {
-      const { rows, found } = pageChoices(page, state.query);
-      const idsOf = (choices: ReadonlyArray<Choice>) =>
-        HashSet.fromIterable(Array.map(choices, ({ id }) => id));
+      const { rows, found, contextIds } = pageChoices(page, state.query);
       return {
         maybePage,
         rows,
-        contextIds: HashSet.difference(idsOf(rows), idsOf(found)),
+        contextIds,
         maybeCursorId: pipe(
           Option.filter(state.maybeCursor, (rowId) => isListed(rows, rowId)),
           Option.orElse(() =>
@@ -657,9 +652,10 @@ const unshiftedOf = (model: Model, commands: ReadonlyArray<Command>): Shown => {
 
 /** The row the cursor is on as the view shows it with `commands`: the row the reader moved it
  *  to while that row is listed, else the page's `start` or `current` while the query finds it,
- *  else the first row the query finds; none when nothing is listed. Compare it before and after the caller's commands change to know
- *  when the cursor fell to another row (its row left) and should be scrolled into view with
- *  `ScrollToCursor`; a cursor whose row is still listed keeps it, and the list its scroll. */
+ *  else the first row the query finds; none when nothing is listed. Compare it before and after
+ *  the caller's commands change to know when the cursor fell to another row (its row left) and
+ *  should be scrolled into view with `ScrollToCursor`; a cursor whose row is still listed keeps
+ *  it, and the list its scroll. */
 export const maybeCursorId = (
   model: Model,
   commands: ReadonlyArray<Command>,

package/src/commandPalette/match.ts

@@ -78,9 +78,11 @@ export const findCommands = (
   return Array.sort(ordered, Order.mapInput(Order.Number, groupIndex));
 };
 
+const isBlank = (query: string): boolean => String.isEmpty(String.trim(query));
+
 /** The choices a page's query finds. */
 export const findChoices = (page: Page, query: string): ReadonlyArray<Choice> =>
-  String.isEmpty(String.trim(query))
+  isBlank(query)
     ? page.choices
     : Array.filter(page.choices, (choice) => matches(query, choice.label));
 
@@ -88,14 +90,22 @@ type Walk = Readonly<{ chain: ReadonlyArray<Choice>; keptIds: HashSet.HashSet<st
 
 const WALK_START: Walk = { chain: [], keptIds: HashSet.empty() };
 
-/** What a page shows for its query: the choices it finds, and the rows, which are those
- *  choices each with the choices it sits under in the page's tree, in the page's order. */
+/** What a page shows for its query: the choices it finds; the rows, which are those choices
+ *  each with the choices it sits under in the page's tree, in the page's order; and the rows
+ *  kept only for the choices under them. */
 export type PageChoices = Readonly<{
   rows: ReadonlyArray<Choice>;
   found: ReadonlyArray<Choice>;
+  contextIds: HashSet.HashSet<string>;
 }>;
 
-export const pageChoices = (page: Page, query: string): PageChoices => {
+const unfiltered = (page: Page): PageChoices => ({
+  rows: page.choices,
+  found: page.choices,
+  contextIds: HashSet.empty(),
+});
+
+const treeChoices = (page: Page, query: string): PageChoices => {
   const found = findChoices(page, query);
   const foundIds = HashSet.fromIterable(Array.map(found, ({ id }) => id));
   const { keptIds } = Array.reduce(page.choices, WALK_START, ({ chain, keptIds }, choice): Walk => {
@@ -107,5 +117,12 @@ export const pageChoices = (page: Page, query: string): PageChoices => {
         : keptIds,
     };
   });
-  return { rows: Array.filter(page.choices, ({ id }) => HashSet.has(keptIds, id)), found };
+  return {
+    rows: Array.filter(page.choices, ({ id }) => HashSet.has(keptIds, id)),
+    found,
+    contextIds: HashSet.difference(keptIds, foundIds),
+  };
 };
+
+export const pageChoices = (page: Page, query: string): PageChoices =>
+  isBlank(query) ? unfiltered(page) : treeChoices(page, query);

package/src/field/field.ts

@@ -48,6 +48,9 @@ export type ViewConfig<Message> = Readonly<{
   isBoxed?: boolean;
   /** Code and identifiers: the system monospace. */
   isMono?: boolean;
+  /** The label is for screen readers only (`.sr-only`): a field whose place says what it is,
+   *  such as a browser's address bar. It still names the input. */
+  isLabelHidden?: boolean;
   /** The input's type (`"date"` for the browser's date control, always boxed); text when not
    *  given. */
   type?: string;
@@ -71,6 +74,7 @@ export const view = <Message>(config: ViewConfig<Message>, h: HtmlBuilder<Messag
     isRequired = false,
     isBoxed = false,
     isMono = false,
+    isLabelHidden = false,
     type,
     inputAttributes = [],
   } = config;
@@ -87,7 +91,7 @@ export const view = <Message>(config: ViewConfig<Message>, h: HtmlBuilder<Messag
         h.div(
           [h.Class(`field${isBoxed || type === "date" ? " boxed" : ""}${isMono ? " mono" : ""}`)],
           [
-            h.label(groups.label, [label]),
+            h.label([...groups.label, ...(isLabelHidden ? [h.Class("sr-only")] : [])], [label]),
             // NOTE: @foldkit/ui gap: Input has no required option, so the wrapper says it.
             h.input([
               ...inputAttributes,

package/src/lineDiff/index.ts

@@ -1,2 +1,4 @@
 export { patchView, view } from "./lineDiff.ts";
 export type { PatchViewConfig, ViewConfig } from "./lineDiff.ts";
+export { describePatch } from "./patch.ts";
+export type { PatchDescription } from "./patch.ts";

package/src/lineDiff/lineDiff.ts

@@ -1,15 +1,9 @@
-import { Array, Option, String } from "effect";
+import { Array, Option } from "effect";
 import type { Html, HtmlBuilder } from "foldkit/html";
 
 import { LOCALE } from "../locale/locale.ts";
-import {
-  DiffRow,
-  type LineKind,
-  diffRowsOf,
-  diffRowsOfPatch,
-  foldUnchanged,
-  hasChanges,
-} from "./diff.ts";
+import { DiffRow, type LineKind, diffRowsOf, foldUnchanged, hasChanges } from "./diff.ts";
+import { SAME_NOTE, readPatch } from "./patch.ts";
 
 // VIEW
 
@@ -29,7 +23,8 @@ export type ViewConfig = Readonly<{
 
 /** Configuration for rendering a unified diff with `patchView`. */
 export type PatchViewConfig = Readonly<{
-  /** One file's unified diff, as `diff -u` or `git diff -- <path>` writes it. */
+  /** One file's unified diff, as `diff -u` or `git diff -- <path>` writes it, its git header
+   *  included. */
   patch: string;
   /** Names the two sides for screen readers: `"Version 3 against version 4"`. */
   label: string;
@@ -86,8 +81,6 @@ const rowView = <Message>(row: DiffRow, h: HtmlBuilder<Message>): Html =>
 const noteView = <Message>(note: string, h: HtmlBuilder<Message>): Html =>
   h.p([h.Class("note-line")], [note]);
 
-const SAME_NOTE = "No difference: both sides hold the same text.";
-
 const tableView = <Message>(
   rows: ReadonlyArray<DiffRow>,
   label: string,
@@ -123,18 +116,30 @@ export const view = <Message>(config: ViewConfig, h: HtmlBuilder<Message>): Html
 /** A unified diff the caller already has (from a server, or `git diff -- <path>`) as `view`'s
  *  table: its hunks' lines, numbered from their headers, and the unchanged lines between hunks
  *  folded into a counted row. Lines past the last hunk are not in the patch, so nothing counts
- *  them. An empty patch says there is no difference, as `view` does; anything but one file
- *  with a hunk (text that is not a diff, a binary change, several files) says it cannot be
- *  shown as lines. */
+ *  them. What git's header says beyond the lines prints as a note line above the table, or in
+ *  its place: a rename, a mode change, an empty or binary file (`describePatch` has the
+ *  sentences). A file whose type changed (a file that became a symlink) is two sections, each
+ *  its own table under one note, named for its side (`"<label>, as it was"`). An empty patch
+ *  says there is no difference, as `view` does; text that is not a diff, or holds several
+ *  files, says it cannot be shown as lines. */
 export const patchView = <Message>(config: PatchViewConfig, h: HtmlBuilder<Message>): Html => {
   const { patch, label } = config;
-
-  if (String.isEmpty(String.trim(patch))) {
-    return noteView(SAME_NOTE, h);
-  } else {
-    return Option.match(diffRowsOfPatch(patch), {
-      onNone: () => noteView("This diff cannot be shown as lines.", h),
-      onSome: (rows) => tableView(rows, label, h),
-    });
-  }
+  const { notes, tables } = readPatch(patch);
+  const parts = [
+    ...(Array.isReadonlyArrayNonEmpty(notes) ? [noteView(Array.join(notes, " "), h)] : []),
+    ...Array.map(tables, ({ rows, maybeSide }) =>
+      tableView(
+        rows,
+        Option.match(maybeSide, { onNone: () => label, onSome: (side) => `${label}, ${side}` }),
+        h,
+      ),
+    ),
+  ];
+
+  // a lone table or note is drawn bare, so a flush window's body still meets its table
+  return Array.match(parts, {
+    onEmpty: () => noteView(SAME_NOTE, h),
+    onNonEmpty: ([part, ...others]) =>
+      Array.isArrayEmpty(others) ? part : h.div([h.Class("stack gap-s")], parts),
+  });
 };

package/src/lineDiff/patch.ts

@@ -0,0 +1,218 @@
+import { Array, Option, String, pipe } from "effect";
+
+import { type DiffRow, diffRowsOfPatch } from "./diff.ts";
+
+// QUOTED PATHS
+
+const ESCAPED_BYTES: Readonly<Record<string, number>> = {
+  a: 7,
+  b: 8,
+  t: 9,
+  n: 10,
+  v: 11,
+  f: 12,
+  r: 13,
+};
+
+// an octal escape is one byte of the name's UTF-8, so the bytes are gathered before decoding
+const QUOTED_PART = /\\([0-7]{3})|\\(.)|[^\\]+/gu;
+
+const bytesOf = (text: string): ReadonlyArray<number> => [...new TextEncoder().encode(text)];
+
+const bytesOfPart = ([part, octal, escaped]: RegExpExecArray): ReadonlyArray<number> => {
+  if (octal !== undefined) {
+    return [Number.parseInt(octal, 8)];
+  } else if (escaped !== undefined) {
+    return Option.match(Option.fromUndefinedOr(ESCAPED_BYTES[escaped]), {
+      onNone: () => bytesOf(escaped),
+      onSome: (byte) => [byte],
+    });
+  } else {
+    return bytesOf(part);
+  }
+};
+
+/** The name a path in git's header stands for: git C-quotes a name with unusual bytes
+ *  (`"caf\303\251.txt"`), and leaves any other as it is. */
+export const unquoted = (path: string): string =>
+  path.length >= 2 && path.startsWith('"') && path.endsWith('"')
+    ? new TextDecoder().decode(
+        Uint8Array.from(
+          Array.flatMap(Array.fromIterable(path.slice(1, -1).matchAll(QUOTED_PART)), bytesOfPart),
+        ),
+      )
+    : path;
+
+// HEADER
+
+const GIT_SECTION = "diff --git ";
+
+// the header is what comes before the first hunk, so a changed line that reads like a header
+// line ("+rename from x") is never taken for one
+const headOf = (section: string): ReadonlyArray<string> =>
+  Array.takeWhile(
+    section.split("\n"),
+    (line) => !line.startsWith("@@") && !line.startsWith("--- "),
+  );
+
+const valueAfter = (head: ReadonlyArray<string>, prefix: string): Option.Option<string> =>
+  pipe(
+    Array.findFirst(head, String.startsWith(prefix)),
+    Option.map((line) => line.slice(prefix.length)),
+  );
+
+const hasLine = (head: ReadonlyArray<string>, prefix: string): boolean =>
+  Option.isSome(valueAfter(head, prefix));
+
+const hasHunk = (section: string): boolean =>
+  Array.some(section.split("\n"), String.startsWith("@@ "));
+
+// git writes one section per file, after whatever precedes the first (a commit's message, a
+// mail's head); a patch without a git header is one section
+const sectionsOf = (patch: string): ReadonlyArray<string> => {
+  const [first = "", ...others] = patch.split(/(?=^diff --git )/mu);
+
+  return Array.isArrayNonEmpty(others) && !first.startsWith(GIT_SECTION)
+    ? others
+    : [first, ...others];
+};
+
+// READING
+
+/** What a diff of two same texts says. */
+export const SAME_NOTE = "No difference: both sides hold the same text.";
+const UNREADABLE_NOTE = "This diff cannot be shown as lines.";
+const BINARY_NOTE = "A binary file: its change has no lines.";
+
+/** A table of the patch's lines; `maybeSide` says which side of a type change it is. */
+type Table = Readonly<{ rows: ReadonlyArray<DiffRow>; maybeSide: Option.Option<string> }>;
+
+/** What `patchView` draws: its notes as a line, then its tables. */
+export type PatchReading = Readonly<{
+  maybeRenamedFrom: Option.Option<string>;
+  notes: ReadonlyArray<string>;
+  tables: ReadonlyArray<Table>;
+}>;
+
+const unreadable: PatchReading = {
+  maybeRenamedFrom: Option.none(),
+  notes: [UNREADABLE_NOTE],
+  tables: [],
+};
+
+const lineNote = (head: ReadonlyArray<string>, hasRows: boolean): Option.Option<string> => {
+  if (hasLine(head, "Binary files ") || hasLine(head, "GIT binary patch")) {
+    return Option.some(BINARY_NOTE);
+  } else if (hasRows) {
+    return Option.none();
+  } else if (hasLine(head, "new file mode ")) {
+    return Option.some("New empty file.");
+  } else if (hasLine(head, "deleted file mode ")) {
+    return Option.some("Deleted empty file.");
+  } else {
+    return Option.none();
+  }
+};
+
+const readSection = (section: string): PatchReading => {
+  const head = headOf(section);
+  const maybeRows = diffRowsOfPatch(section);
+  const maybeRenamedFrom = Option.map(valueAfter(head, "rename from "), unquoted);
+  const notes = [
+    ...Option.toArray(Option.map(maybeRenamedFrom, (from) => `Renamed from ${from}.`)),
+    ...Option.toArray(
+      Option.map(
+        Option.all({ before: valueAfter(head, "old mode "), after: valueAfter(head, "new mode ") }),
+        ({ before, after }) => `Mode ${before} → ${after}.`,
+      ),
+    ),
+    ...Option.toArray(lineNote(head, Option.isSome(maybeRows))),
+  ];
+  const isUnread = Option.isNone(maybeRows) && (hasHunk(section) || Array.isArrayEmpty(notes));
+
+  return isUnread
+    ? unreadable
+    : {
+        maybeRenamedFrom,
+        notes,
+        tables: Option.toArray(
+          Option.map(maybeRows, (rows) => ({ rows, maybeSide: Option.none() })),
+        ),
+      };
+};
+
+const KINDS: Readonly<Record<string, string>> = {
+  "100644": "a file",
+  "100755": "an executable file",
+  "120000": "a symlink",
+  "160000": "a submodule",
+};
+
+const kindOf = (mode: string): string => KINDS[mode] ?? `mode ${mode}`;
+
+const sideTable = (section: string, side: string): ReadonlyArray<Table> =>
+  Option.toArray(
+    Option.map(diffRowsOfPatch(section), (rows) => ({ rows, maybeSide: Option.some(side) })),
+  );
+
+// a file that became a symlink (or any other kind) is two sections for one path: the old
+// kind deleted, then the new one added
+const readTypeChange = (gone: string, added: string): Option.Option<PatchReading> => {
+  const [goneHead, addedHead] = [headOf(gone), headOf(added)];
+
+  return Option.flatMap(
+    Option.all({
+      before: valueAfter(goneHead, "deleted file mode "),
+      after: valueAfter(addedHead, "new file mode "),
+    }),
+    ({ before, after }) =>
+      goneHead[0] === addedHead[0]
+        ? Option.some({
+            maybeRenamedFrom: Option.none(),
+            notes: [`It was ${kindOf(before)} and is now ${kindOf(after)}.`],
+            tables: [...sideTable(gone, "as it was"), ...sideTable(added, "as it is")],
+          })
+        : Option.none(),
+  );
+};
+
+/** What `patchView` makes of a patch: the notes it prints and the tables it draws. */
+export const readPatch = (patch: string): PatchReading => {
+  const text = patch.replaceAll("\r\n", "\n");
+
+  if (String.isEmpty(String.trim(text))) {
+    return { maybeRenamedFrom: Option.none(), notes: [SAME_NOTE], tables: [] };
+  } else {
+    const sections = sectionsOf(text);
+    const [first, second, ...rest] = sections;
+
+    if (first !== undefined && second === undefined) {
+      return readSection(first);
+    } else if (first !== undefined && second !== undefined && Array.isArrayEmpty(rest)) {
+      return Option.getOrElse(readTypeChange(first, second), () => unreadable);
+    } else {
+      return unreadable;
+    }
+  }
+};
+
+// DESCRIPTION
+
+/** What a patch says beyond its lines, as `patchView` prints it. */
+export type PatchDescription = Readonly<{
+  /** The path a rename left, unquoted: for a heading such as `old.txt → new.txt`. */
+  maybeRenamedFrom: Option.Option<string>;
+  /** The sentences `patchView` prints above the patch's lines, or in their place: a rename,
+   *  a mode change, a type change, an empty or binary file, no difference, or a patch it
+   *  cannot show as lines. */
+  notes: ReadonlyArray<string>;
+}>;
+
+/** What `patchView` says about a patch from `git diff`, read from its header: the notes it
+ *  prints (`["Renamed from old.txt."]`), for a caller that prints them itself, and the path a
+ *  rename left. */
+export const describePatch = (patch: string): PatchDescription => {
+  const { maybeRenamedFrom, notes } = readPatch(patch);
+
+  return { maybeRenamedFrom, notes };
+};

package/src/pixel-paper.css

@@ -5151,6 +5151,12 @@ dialog.veil:focus {
   color: inherit;
 }
 
+/* a child Submodel's tools come back as one element; the group is no box of its own, so its
+   buttons take the bar's gap as the others do */
+.window-tools {
+  display: contents;
+}
+
 .window-body {
   flex: 1;
   min-height: 0;

package/src/reel/layout.ts

@@ -111,10 +111,12 @@ export const columnOf = (layout: Layout, columnId: string): Option.Option<Column
 const nextColumnId = (layout: Layout, columnIndex: number): Option.Option<string> =>
   Option.map(Array.get(layout, columnIndex + 1), (column) => column.id);
 
+// a running mean, which never passes the largest weight, where the weights' sum may overflow
 const meanWeight = (panes: ReadonlyArray<Pane>): number =>
   Array.match(panes, {
     onEmpty: () => 1,
-    onNonEmpty: (some) => Number.sumAll(Array.map(some, (pane) => pane.weight)) / some.length,
+    onNonEmpty: (some) =>
+      Array.reduce(some, 0, (mean, pane, index) => mean + (pane.weight - mean) / (index + 1)),
   });
 
 const othersIn = (column: Column, paneId: string): ReadonlyArray<Pane> =>
@@ -562,10 +564,21 @@ const PRECISION = 10_000;
 
 const rounded = (value: number): number => Math.round(value * PRECISION) / PRECISION;
 
+/** `weight`, at least `floor`, to four decimals, or, where a step of four decimals is more than
+ *  `floor` (a column whose weights total under a five-hundredth, or two panes that small), to
+ *  the first power of ten no more than it, so that it never rounds to nothing. A weight too
+ *  large or a floor too small to scale by that power is left as it is. */
+const roundedOver = (weight: number, floor: number): number => {
+  const precision = Math.max(PRECISION, 10 ** Math.ceil(-Math.log10(floor)));
+  const scaled = weight * precision;
+  return globalThis.Number.isFinite(scaled) ? Math.round(scaled) / precision : weight;
+};
+
 /** What moving `splitter` by `share` asks of the layout, from the sizes the layout holds (not
  *  the sizes printed, which the stylesheet may hold at a minimum): a width splitter adds
  *  `share` to its column's width; a pane splitter moves `share` of its column's height from
- *  the pane below it to the pane above. None when what it sizes is gone. */
+ *  the pane below it to the pane above, leaving each a weight above nothing however small the
+ *  column. None when what it sizes is gone. */
 export const resizeOf = (
   layout: Layout,
   splitter: Splitter,
@@ -584,14 +597,24 @@ export const resizeOf = (
         Option.map(Array.get(column.panes, row + 1), (below) => {
           const total = Number.sumAll(Array.map(column.panes, ({ weight }) => weight));
           const pair = above.weight + below.weight;
-          const floor = Math.min(total * SHARE_FLOOR, pair / 2);
+          // a column so small that a twentieth of it is no number keeps the least there is
+          const floor = Math.max(
+            Math.min(total * SHARE_FLOOR, pair / 2),
+            globalThis.Number.MIN_VALUE,
+          );
           const nextAbove = Number.clamp(above.weight + share * total, {
             minimum: floor,
             maximum: pair - floor,
           });
           return OutMessage.ResizedPanes({
             columnId: column.id,
-            weights: { [above.id]: rounded(nextAbove), [below.id]: rounded(pair - nextAbove) },
+            weights: globalThis.Number.isFinite(total)
+              ? {
+                  [above.id]: roundedOver(nextAbove, floor),
+                  [below.id]: roundedOver(pair - nextAbove, floor),
+                }
+              : // weights that total past the largest number have no share to move: they stay
+                { [above.id]: above.weight, [below.id]: below.weight },
           });
         }),
       ),

package/src/window/window.ts

@@ -20,7 +20,9 @@ export type ViewConfig<Message> = Readonly<{
   glyph?: GlyphName;
   /** A chip in the title bar: its state. */
   status?: ReadonlyArray<Html | string>;
-  /** IconButtons in the title bar, before the close. */
+  /** IconButtons in the title bar, before the close. A child Submodel, whose view is one
+   *  `Html`, hands back several in a `span.window-tools`: it is no box of its own
+   *  (`display: contents`), so its buttons sit in the bar as the others do. */
   tools?: ReadonlyArray<Html>;
   /** The close glyph's Message; the glyph prints when it is given. */
   onClose?: Message;