@skillcdn/console 0.3.2 → 0.4.1

package/src/cli/pack.ts

@@ -264,11 +264,20 @@ export function joinFolder(
   if (first === undefined || last === undefined) {
     return undefined;
   }
+  // A file's path answers its outline (SkillCDN 0.4), its headings paged as a folder's entries are.
+  const outline =
+    first.outline === undefined
+      ? undefined
+      : {
+          ...first.outline,
+          headings: results.flatMap((result) => result.outline?.headings ?? []),
+        };
   return {
     ...first,
     mount: last.mount,
     entries: results.flatMap((result) => result.entries),
     nextCursor: last.nextCursor,
+    ...(outline === undefined ? {} : { outline }),
   };
 }
 
@@ -304,10 +313,16 @@ export function formatSkillFind(found: RestSkillFind, summary: PackSummary | und
   return renderFindResult(findResultOf(found.read, summary), CONSOLE_WORDS);
 }
 
-/** The pages of a file, as the console answered them, as the file whole; or the folder the path named. */
+/**
+ * The pages of a file, as the console answered them, as the file whole; or the folder the path
+ * named. With `requested`, the one page is a section read as asked (`--offset`, `--limit`): the
+ * result carries the length asked for, so that the renderer says where the file continues rather
+ * than asking for the rest.
+ */
 export function joinFile(
   pages: readonly RestSkillFile[],
   summary: PackSummary,
+  requested?: number,
 ): FileResult | DirectoryResult | undefined {
   const reads = pages.flatMap((page) => (page.read === null ? [] : [page.read]));
   const first = reads[0];
@@ -331,6 +346,7 @@ export function joinFile(
     content: files.map((file) => file.content).join(""),
     nextOffset: closing.nextOffset,
     totalLength: closing.totalLength,
+    ...(requested === undefined ? {} : { requestedLength: requested }),
   };
 }
 

package/src/client.ts

@@ -44,6 +44,7 @@ import {
   type RestMemberPatch,
   type RestMembers,
   type RestMePatch,
+  type RestMyDecisions,
   type RestPackConnect,
   type RestPackConnectStarted,
   type RestPackTokenInput,
@@ -101,6 +102,7 @@ import {
   restMemberSchema,
   restMembersSchema,
   restMeSchema,
+  restMyDecisionsSchema,
   restPackConnectSchema,
   restPackConnectStartedSchema,
   restPeopleSchema,
@@ -206,6 +208,8 @@ export interface EventFilter {
   readonly run?: string | undefined;
   readonly decision?: string | undefined;
   readonly document?: string | undefined;
+  /** True for the newest events, oldest first, and whether there are earlier ones; `after` is not looked at then. */
+  readonly latest?: boolean | undefined;
 }
 
 /** One page of a listing: how many items, from which one on; the server's bounds apply. */
@@ -362,8 +366,14 @@ export interface ProjectClient {
   removePackToken(): Promise<RestProject>;
   /** Asks the deployment to connect the project's pack with a code a person approves (ADR-0036); for an owner. */
   connectPackToken(): Promise<RestPackConnectStarted>;
-  /** How that connection stands; the token is kept when the person approved. For an owner. */
+  /** How that connection stands, read and changed nothing: pending, ended, or none; for an owner. */
   packTokenConnection(signal?: AbortSignal): Promise<RestPackConnect>;
+  /**
+   * Asks the console to claim the token at the deployment (ADR-0046): pending while the person
+   * has not approved, connected once, the token kept and the project as it stands, or ended;
+   * for an owner.
+   */
+  claimPackTokenConnection(signal?: AbortSignal): Promise<RestPackConnect>;
   /** Gives the connection up; for an owner. */
   cancelPackTokenConnection(): Promise<void>;
   /** The rules that hold in the project (ADR-0023): the workspace's, and what the project adds. */
@@ -412,6 +422,7 @@ export interface ConsoleClient {
   removeWorkspacePackToken(): Promise<RestWorkspace>;
   connectWorkspacePackToken(): Promise<RestPackConnectStarted>;
   workspacePackTokenConnection(signal?: AbortSignal): Promise<RestWorkspacePackConnect>;
+  claimWorkspacePackTokenConnection(signal?: AbortSignal): Promise<RestWorkspacePackConnect>;
   cancelWorkspacePackTokenConnection(): Promise<void>;
   /** The people the asker may see: everyone, or those they share a project with (ADR-0035). */
   people(signal?: AbortSignal): Promise<RestPeople>;
@@ -434,6 +445,8 @@ export interface ConsoleClient {
   project(key: string): ProjectClient;
   /** The workspace's own events, the ones about no project, after event number `after`. */
   events(after: number, signal?: AbortSignal): Promise<RestEvents>;
+  /** Where a picture from elsewhere is read through the console (ADR-0048), given the https URL that names it. */
+  pictureUrl(url: string): string;
   /** The categories tasks are sorted into (ADR-0019), by name. */
   categories(signal?: AbortSignal): Promise<RestCategories>;
   /** The workspace's rules (ADR-0023): the console's own until an administrator writes the organization's. */
@@ -449,8 +462,13 @@ export interface ConsoleClient {
   updateCategory(key: string, patch: RestCategoryPatch): Promise<RestCategory>;
   /** Removes a category no task uses; for an administrator signed in. */
   removeCategory(key: string): Promise<void>;
-  /** What is on the asker's plate across the projects they may see: their open tasks, and the decisions waiting. */
+  /** What is on the asker's plate across the projects they may see: their open tasks, and the decisions waiting for them. */
   work(signal?: AbortSignal): Promise<RestWork>;
+  /** The decisions addressed to the asker (ADR-0042) across the projects they may see, or with `raised` those they raised for someone else: a page, the waiting first; or only those. */
+  myDecisions(
+    filter?: { readonly open?: boolean; readonly raised?: boolean } & Page,
+    signal?: AbortSignal,
+  ): Promise<RestMyDecisions>;
   /** Another person's plate, within what the asker may see: for an administrator, or an owner of a project they are in. */
   personWork(personId: string, signal?: AbortSignal): Promise<RestPersonWork>;
   /** The tokens of whoever asks. */
@@ -745,6 +763,7 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
           "GET",
           withQuery(at("events"), {
             after: String(after),
+            latest: filter.latest === true ? "true" : undefined,
             task: filter.task,
             run: filter.run,
             decision: filter.decision,
@@ -821,6 +840,14 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
           restPackConnectSchema,
           signal,
         ),
+      claimPackTokenConnection: (signal) =>
+        request(
+          "POST",
+          `${base}${at()}/pack-token/connect/claim`,
+          undefined,
+          restPackConnectSchema,
+          signal,
+        ),
       cancelPackTokenConnection: () =>
         request("DELETE", `${base}${at()}/pack-token/connect`, undefined, undefined),
       rules: (signal) =>
@@ -924,6 +951,14 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
         restWorkspacePackConnectSchema,
         signal,
       ),
+    claimWorkspacePackTokenConnection: (signal) =>
+      request(
+        "POST",
+        `${base}${REST_ROUTES.workspacePackToken}/connect/claim`,
+        undefined,
+        restWorkspacePackConnectSchema,
+        signal,
+      ),
     cancelWorkspacePackTokenConnection: () =>
       request("DELETE", `${base}${REST_ROUTES.workspacePackToken}/connect`, undefined, undefined),
     updatePerson: (id, patch) =>
@@ -945,6 +980,7 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
         restEventsSchema,
         signal,
       ),
+    pictureUrl: (url) => withQuery(REST_ROUTES.pictures, { src: url }),
     categories: (signal) =>
       request("GET", `${base}${REST_ROUTES.categories}`, undefined, restCategoriesSchema, signal),
     rules: (signal) =>
@@ -961,6 +997,19 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
     removeCategory: (key) => request("DELETE", `${base}${categoryPath(key)}`, undefined, undefined),
     work: (signal) =>
       request("GET", `${base}${REST_ROUTES.work}`, undefined, restWorkSchema, signal),
+    myDecisions: (filter = {}, signal) =>
+      request(
+        "GET",
+        withQuery(REST_ROUTES.decisions, {
+          open: flag(filter.open),
+          raised: filter.raised === true ? "true" : undefined,
+          limit: number(filter.limit),
+          offset: number(filter.offset),
+        }),
+        undefined,
+        restMyDecisionsSchema,
+        signal,
+      ),
     personWork: (personId, signal) =>
       request("GET", `${base}${personWorkPath(personId)}`, undefined, restPersonWorkSchema, signal),
     tokens: (signal) =>

package/src/compat.ts

@@ -113,7 +113,7 @@ export interface ClientPolicy {
  * last changed what the command reads or sends (ADR-0038), whose changelog entry begins with
  * `Breaking:`; `pnpm check` holds it to a version the package has, or is about to have.
  */
-export const CLIENT_POLICY: ClientPolicy = { atLeast: "0.3.2" };
+export const CLIENT_POLICY: ClientPolicy = { atLeast: "0.4.1" };
 
 /**
  * The oldest console this command works with (ADR-0038): raised by the release that last
@@ -122,7 +122,7 @@ export const CLIENT_POLICY: ClientPolicy = { atLeast: "0.3.2" };
  * itself, naming the command to install instead; `pnpm check` holds it as it holds the
  * console's floor.
  */
-export const CONSOLE_AT_LEAST = "0.3.2";
+export const CONSOLE_AT_LEAST = "0.4.1";
 
 /** `common` from `atLeast` on, where that floor is within it; `common` as it is otherwise. */
 function narrowed(common: VersionRange, atLeast: string | undefined): VersionRange {

package/src/components/board.tsx

@@ -59,8 +59,17 @@ export interface BoardProps {
   readonly onEdit?: ((task: RestTask) => void) | undefined;
   /** Called when a task is put away from its card's menu (ADR-0029, ADR-0030). Left out, the menu offers nothing of it. */
   readonly onArchive?: ((task: RestTask) => void) | undefined;
+  /**
+   * The columns folded to a strip until a person opens them, with their count and the way to open
+   * them; a folded column still takes a card dragged onto it. What is finished, by default, so that
+   * the work at hand has the room; `[]` folds none.
+   */
+  readonly folded?: readonly TaskState[] | undefined;
 }
 
+/** The columns a board folds unless told otherwise: the work that is over. */
+export const FOLDED_STATES: readonly TaskState[] = ["done", "dropped"];
+
 /** How far a mouse travels on a card before the press is a drag and not a click. */
 const DRAG_SLACK = 4;
 /**
@@ -160,7 +169,7 @@ export function TaskCard(props: TaskCardProps) {
           <DueBadge dueOn={task.dueOn} state={task.state} today={props.today} />
         )}
         {task.openDecisions > 0 && (
-          <Badge tone="warning" title={words.board.decisionsTitle}>
+          <Badge tone="warning" kind="count" title={words.board.decisionsTitle}>
             {words.board.decisions(task.openDecisions)}
           </Badge>
         )}
@@ -364,6 +373,19 @@ export function Board(props: BoardProps) {
   const { onMove } = props;
   const board = useRef<HTMLDivElement>(null);
   const [drag, setDrag] = useState<Drag | null>(null);
+  // The foldable columns a person has opened on this board; the others of them stay folded.
+  const [opened, setOpened] = useState<ReadonlySet<TaskState>>(() => new Set());
+  const foldable = props.folded ?? FOLDED_STATES;
+  const toggle = (state: TaskState) =>
+    setOpened((before) => {
+      const after = new Set(before);
+      if (after.has(state)) {
+        after.delete(state);
+      } else {
+        after.add(state);
+      }
+      return after;
+    });
   // What the pointer's release reads, so that the move is made outside a state update.
   const current = useRef<Drag | null>(null);
   current.current = drag;
@@ -511,38 +533,65 @@ export function Board(props: BoardProps) {
     >
       {TASK_STATES.map((state) => {
         const tasks = props.tasks.filter((task) => task.state === state).sort(byDue);
+        const name = words.vocabulary.state[state];
+        const canFold = foldable.includes(state);
+        const folded = canFold && !opened.has(state);
         return (
           <section
             key={state}
             className={cx(
               "sc-column",
               `sc-column-${state}`,
+              folded && "sc-column-folded",
               dragging?.over === state && "sc-column-over",
             )}
-            aria-label={words.vocabulary.state[state]}
+            aria-label={name}
             data-column={state}
           >
             <header className="sc-column-header">
-              <h2 className="sc-column-title">{words.vocabulary.state[state]}</h2>
+              <h2 className="sc-column-title">{name}</h2>
               <span className="sc-column-count">{tasks.length}</span>
+              {canFold && (
+                <button
+                  type="button"
+                  className="sc-column-toggle"
+                  aria-expanded={!folded}
+                  aria-label={folded ? words.board.unfold(name) : words.board.fold(name)}
+                  title={folded ? words.board.unfold(name) : words.board.fold(name)}
+                  onClick={() => toggle(state)}
+                >
+                  <svg viewBox="0 0 16 16" aria-hidden="true">
+                    <path
+                      d={folded ? "M6 4l4 4-4 4" : "M10 4l-4 4 4 4"}
+                      fill="none"
+                      stroke="currentColor"
+                      strokeWidth="1.5"
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                    />
+                  </svg>
+                </button>
+              )}
             </header>
-            <div className="sc-column-body">
-              {tasks.map((task) => (
-                <TaskCard
-                  key={task.id}
-                  task={task}
-                  href={props.taskHref(task)}
-                  onOpen={props.onOpen}
-                  today={props.today}
-                  onPress={onMove === undefined ? undefined : press}
-                  dragging={dragging?.task.id === task.id}
-                  editHref={props.editHref?.(task)}
-                  onEdit={props.onEdit}
-                  onArchive={props.onArchive}
-                />
-              ))}
-              {tasks.length === 0 && state === "idea" && props.empty}
-            </div>
+            {!folded && (
+              <div className="sc-column-body">
+                {tasks.map((task) => (
+                  <TaskCard
+                    key={task.id}
+                    task={task}
+                    href={props.taskHref(task)}
+                    onOpen={props.onOpen}
+                    today={props.today}
+                    onPress={onMove === undefined ? undefined : press}
+                    dragging={dragging?.task.id === task.id}
+                    editHref={props.editHref?.(task)}
+                    onEdit={props.onEdit}
+                    onArchive={props.onArchive}
+                  />
+                ))}
+                {tasks.length === 0 && state === "idea" && props.empty}
+              </div>
+            )}
           </section>
         );
       })}
@@ -571,13 +620,43 @@ export function Board(props: BoardProps) {
   );
 }
 
-/** What the filter keeps of the board: a category or none, a goal or none, a person, one's own. */
+/** What a task is found by: its title, its number, its owner and its workers, its category. */
+function wordsOf(task: RestTask): string {
+  return [
+    task.title,
+    `#${task.number}`,
+    personName(task.owner),
+    task.owner.login,
+    ...task.workers.flatMap((worker) => [personName(worker), worker.login]),
+    task.category?.name ?? "",
+  ]
+    .join("\n")
+    .toLowerCase();
+}
+
+/**
+ * What the filter keeps of the board: a category or none, a goal or none, a person, one's own,
+ * and the tasks that contain every word typed, whatever the case.
+ */
 export function filterTasks(
   tasks: readonly RestTask[],
   filter: BoardFilter,
   me?: RestPerson | undefined,
 ): RestTask[] {
+  const wanted =
+    filter.words === undefined
+      ? []
+      : filter.words
+          .toLowerCase()
+          .split(/\s+/)
+          .filter((word) => word.length > 0);
   return tasks.filter((task) => {
+    if (wanted.length > 0) {
+      const found = wordsOf(task);
+      if (!wanted.every((word) => found.includes(word))) {
+        return false;
+      }
+    }
     if (filter.category !== undefined && (task.category?.key ?? "") !== filter.category) {
       return false;
     }
@@ -633,6 +712,20 @@ export function BoardFilters(props: BoardFiltersProps) {
       aria-label={words.aria}
       onSubmit={(event) => event.preventDefault()}
     >
+      <label className="sc-field sc-field-inline sc-filters-words">
+        <span className="sc-visually-hidden">{words.words}</span>
+        <input
+          className="sc-input"
+          type="search"
+          placeholder={words.words}
+          value={filter.words ?? ""}
+          onChange={(event) =>
+            event.target.value.trim() === ""
+              ? change({}, "words")
+              : change({ words: event.target.value })
+          }
+        />
+      </label>
       <label className="sc-field sc-field-inline">
         <span className="sc-visually-hidden">{words.anyCategory}</span>
         <select