@skillcdn/console 0.1.24 → 0.3.1

package/src/client.ts

@@ -44,6 +44,8 @@ import {
   type RestMemberPatch,
   type RestMembers,
   type RestMePatch,
+  type RestPackConnect,
+  type RestPackConnectStarted,
   type RestPackTokenInput,
   type RestPeople,
   type RestPerson,
@@ -76,6 +78,9 @@ import {
   type RestVersion,
   type RestVersions,
   type RestWork,
+  type RestWorkspace,
+  type RestWorkspacePackConnect,
+  type RestWorkspacePatch,
   restArchivedTasksSchema,
   restCategoriesSchema,
   restCategorySchema,
@@ -96,6 +101,8 @@ import {
   restMemberSchema,
   restMembersSchema,
   restMeSchema,
+  restPackConnectSchema,
+  restPackConnectStartedSchema,
   restPeopleSchema,
   restPersonSchema,
   restPersonWorkSchema,
@@ -117,6 +124,8 @@ import {
   restVersionSchema,
   restVersionsSchema,
   restWorkSchema,
+  restWorkspacePackConnectSchema,
+  restWorkspaceSchema,
 } from "./schemas.js";
 import type { GoalState, TaskState } from "./vocabulary.js";
 
@@ -345,6 +354,12 @@ export interface ProjectClient {
   setPackToken(input: RestPackTokenInput): Promise<RestProject>;
   /** Takes the pack token away; for an owner. */
   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. */
+  packTokenConnection(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. */
   rules(signal?: AbortSignal): Promise<RestProjectRules>;
   /** A folder's pages and folders, or the pages a search finds. */
@@ -380,7 +395,26 @@ export interface ConsoleClient {
   giveUpToken(): Promise<void>;
   /** Keeps the person's choice of language, or none; for a person signed in. */
   updateMe(patch: RestMePatch): Promise<RestMe>;
+  /** Changes the workspace's settings (ADR-0035); for an administrator, with a session or a token. */
+  updateWorkspace(patch: RestWorkspacePatch): Promise<RestWorkspace>;
+  /**
+   * The workspace's SkillCDN token (ADR-0036), which reads the organization's pack for every
+   * project that names no address and holds no token of its own; an administrator's. Set from
+   * a token made by hand, taken away, or connected with a code a person approves at SkillCDN,
+   * asked after until the token is kept or the request ended.
+   */
+  setWorkspacePackToken(input: RestPackTokenInput): Promise<RestWorkspace>;
+  removeWorkspacePackToken(): Promise<RestWorkspace>;
+  connectWorkspacePackToken(): Promise<RestPackConnectStarted>;
+  workspacePackTokenConnection(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>;
+  /**
+   * One person of the workspace by their exact login, compared without regard to case, or
+   * nobody: what an owner lists someone by when the People page does not show them.
+   */
+  findPerson(login: string, signal?: AbortSignal): Promise<RestPerson | undefined>;
   /** Changes what a person is, or whether they are in; for an administrator. */
   updatePerson(id: string, patch: RestPersonPatch): Promise<RestPerson>;
   /** Lets a login in (ADR-0022): whoever signs in with that account becomes a person; for an administrator. */
@@ -766,6 +800,23 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
         request("PUT", `${base}${at()}/pack-token`, input, restProjectSchema),
       removePackToken: () =>
         request("DELETE", `${base}${at()}/pack-token`, undefined, restProjectSchema),
+      connectPackToken: () =>
+        request(
+          "POST",
+          `${base}${at()}/pack-token/connect`,
+          undefined,
+          restPackConnectStartedSchema,
+        ),
+      packTokenConnection: (signal) =>
+        request(
+          "GET",
+          `${base}${at()}/pack-token/connect`,
+          undefined,
+          restPackConnectSchema,
+          signal,
+        ),
+      cancelPackTokenConnection: () =>
+        request("DELETE", `${base}${at()}/pack-token/connect`, undefined, undefined),
       rules: (signal) =>
         request("GET", `${base}${at("rules")}`, undefined, restProjectRulesSchema, signal),
       documents: (filter = {}, signal) =>
@@ -829,6 +880,39 @@ export function createClient(options: ClientOptions = {}): ConsoleClient {
     giveUpToken: () => request("DELETE", `${base}${REST_ROUTES.meToken}`, undefined, undefined),
     people: (signal) =>
       request("GET", `${base}${REST_ROUTES.people}`, undefined, restPeopleSchema, signal),
+    findPerson: async (login, signal) => {
+      const found = await request(
+        "GET",
+        withQuery(REST_ROUTES.people, { login }),
+        undefined,
+        restPeopleSchema,
+        signal,
+      );
+      return found.items[0];
+    },
+    updateWorkspace: (patch) =>
+      request("PATCH", `${base}${REST_ROUTES.workspace}`, patch, restWorkspaceSchema),
+    setWorkspacePackToken: (input) =>
+      request("PUT", `${base}${REST_ROUTES.workspacePackToken}`, input, restWorkspaceSchema),
+    removeWorkspacePackToken: () =>
+      request("DELETE", `${base}${REST_ROUTES.workspacePackToken}`, undefined, restWorkspaceSchema),
+    connectWorkspacePackToken: () =>
+      request(
+        "POST",
+        `${base}${REST_ROUTES.workspacePackToken}/connect`,
+        undefined,
+        restPackConnectStartedSchema,
+      ),
+    workspacePackTokenConnection: (signal) =>
+      request(
+        "GET",
+        `${base}${REST_ROUTES.workspacePackToken}/connect`,
+        undefined,
+        restWorkspacePackConnectSchema,
+        signal,
+      ),
+    cancelWorkspacePackTokenConnection: () =>
+      request("DELETE", `${base}${REST_ROUTES.workspacePackToken}/connect`, undefined, undefined),
     updatePerson: (id, patch) =>
       request("PATCH", `${base}${restPath("people", id)}`, patch, restPersonSchema),
     createListing: (input) =>

package/src/compat.ts

@@ -75,7 +75,7 @@ export function inRange(version: Version, range: VersionRange): boolean {
 
 /**
  * The common rule. Before 1.0, a command from the console's own version on and within the
- * console's minor (`^0.1.18`): any release may change the contract until then (ADR-0007), so the
+ * console's minor (`^0.1.18`): any release may change the contract until then (ADR-0034), so the
  * console's own version is the floor, and the minor is the line. From 1.0, the console's major
  * and a minor within one of the console's, either way, whatever the patch: a minor adds and a
  * major breaks, as the version promises from then on.

package/src/components/calendar.tsx

@@ -5,11 +5,13 @@ import {
   type RestGoal,
   type RestPerson,
   type RestTask,
+  type WeekStart,
 } from "../api.js";
 import {
   addDays,
   addMonths,
   daysBetween,
+  deviceLanguage,
   firstDayOfWeek,
   formatDay,
   formatDays,
@@ -55,6 +57,8 @@ export interface CalendarProps {
   readonly goalHref?: ((goal: RestGoal) => string) | undefined;
   /** Where the calendar is on another month. */
   readonly monthHref: (month: string) => string;
+  /** The day the weeks begin on, as the workspace says (ADR-0035); the language's when left out. */
+  readonly weekStart?: WeekStart | undefined;
 }
 
 /** One task's stretch across one week: which columns it covers, and in which lane it lies. */
@@ -469,7 +473,7 @@ export function Calendar(props: CalendarProps) {
   const { tag } = useLanguage();
   const [pointed, point, leave] = usePointed();
   const now = props.today ?? todayOf();
-  const firstDay = firstDayOfWeek(tag);
+  const firstDay = firstDayOfWeek(deviceLanguage(tag), props.weekStart);
   const weeks = monthGrid(props.month, firstDay);
   const on = onDays(props.tasks);
   const goalsOn = props.goalHref === undefined ? undefined : goalsOnDays(props.goals ?? []);
@@ -567,6 +571,8 @@ export interface WeekProps {
   readonly weekHref: (day: string) => string;
   /** What stands before a task's title where the tasks are of several projects: the project's mark. */
   readonly markOf?: ((task: RestTask) => ReactNode) | undefined;
+  /** The day the week begins on, as the workspace says (ADR-0035); the language's when left out. */
+  readonly weekStart?: WeekStart | undefined;
 }
 
 /** One week on its own: the days as columns, the tasks on them, and the weeks around a step away. */
@@ -575,7 +581,7 @@ export function Week(props: WeekProps) {
   const { tag } = useLanguage();
   const [pointed, point, leave] = usePointed();
   const now = props.today ?? todayOf();
-  const firstDay = firstDayOfWeek(tag);
+  const firstDay = firstDayOfWeek(deviceLanguage(tag), props.weekStart);
   const days = weekOf(props.day ?? now, firstDay);
   const first = days[0] ?? now;
   const last = days[days.length - 1] ?? now;

package/src/components/decision-list.tsx

@@ -3,6 +3,7 @@ import {
   agentLabel,
   MAX_BODY_LENGTH,
   MAX_NOTE_LENGTH,
+  MAX_OPTION_LABEL_LENGTH,
   type RestAnswerInput,
   type RestDecision,
   type RestDecisionPatch,
@@ -10,8 +11,8 @@ import {
 } from "../api.js";
 import { useWords } from "../i18n/index.js";
 import { Markdown } from "./markdown.js";
-import { ShowMore, usePaged } from "./paged.js";
-import { Button, cx, PersonChip, Time } from "./ui.js";
+import { Pager, pageOf, RECORD_PAGE_SIZE } from "./paged.js";
+import { Badge, Button, cx, PersonChip, Time } from "./ui.js";
 
 // The decisions: the ones that wait, each a card with the way to answer it, since they are what
 // a person came for; and the ones answered, the record, a row each, since they are read back
@@ -35,6 +36,131 @@ export interface DecisionCardProps {
   readonly busy?: boolean | undefined;
 }
 
+/** Who asked, and when: the person, through their agent when a run asked. */
+function Asked(props: { readonly decision: RestDecision; readonly day?: boolean }) {
+  const words = useWords();
+  const { decision } = props;
+  return (
+    <>
+      <PersonChip person={decision.raisedBy} />{" "}
+      {decision.run === null
+        ? words.decisions.asked
+        : words.decisions.askedThrough(agentLabel(decision.run.agent))}{" "}
+      <Time iso={decision.createdAt} precision={props.day === true ? "day" : "minute"} />
+    </>
+  );
+}
+
+/** What was chosen: the option's label, marked when it is the person's own words. */
+function Chosen(props: { readonly decision: RestDecision }) {
+  const words = useWords();
+  const { decision } = props;
+  const chosen = decision.options.find((option) => option.id === decision.answer?.option);
+  return (
+    <>
+      <span>{chosen?.label ?? decision.answer?.option ?? ""}</span>
+      {chosen?.own === true && <Badge>{words.decisions.ownAnswer}</Badge>}
+    </>
+  );
+}
+
+/**
+ * The way to answer: one of the options, or a line of one's own, which is chosen by writing
+ * on it; and a word about either.
+ */
+function AnswerForm(props: {
+  readonly decision: RestDecision;
+  readonly onAnswer: (decision: RestDecision, input: RestAnswerInput) => void;
+  readonly busy: boolean | undefined;
+}) {
+  const words = useWords();
+  const { decision } = props;
+  const [chosen, setChosen] = useState<string | undefined>(undefined);
+  const [own, setOwn] = useState(false);
+  const [ownText, setOwnText] = useState("");
+  const [note, setNote] = useState("");
+  const chooseOwn = () => {
+    setOwn(true);
+    setChosen(undefined);
+  };
+  const answer: RestAnswerInput | undefined = own
+    ? ownText.trim().length > 0
+      ? { own: ownText.trim() }
+      : undefined
+    : chosen === undefined
+      ? undefined
+      : { option: chosen };
+  const name = `decision-${decision.id}`;
+  return (
+    <form
+      className="sc-answer-form"
+      onSubmit={(event) => {
+        event.preventDefault();
+        if (answer !== undefined) {
+          props.onAnswer(decision, {
+            ...answer,
+            ...(note.trim() === "" ? {} : { note: note.trim() }),
+          });
+        }
+      }}
+    >
+      <div className="sc-options-list" role="radiogroup" aria-label={words.decisions.options}>
+        {decision.options.map((option) => (
+          <label
+            key={option.id}
+            className={cx("sc-option", chosen === option.id && "sc-option-chosen")}
+          >
+            <input
+              type="radio"
+              name={name}
+              value={option.id}
+              checked={chosen === option.id}
+              onChange={() => {
+                setChosen(option.id);
+                setOwn(false);
+              }}
+            />
+            <span>{option.label}</span>
+          </label>
+        ))}
+        <label className={cx("sc-option", "sc-option-own", own && "sc-option-chosen")}>
+          <input type="radio" name={name} value="own" checked={own} onChange={chooseOwn} />
+          <span>{words.decisions.own}</span>
+          <input
+            className="sc-input"
+            aria-label={words.decisions.own}
+            placeholder={words.decisions.ownPlaceholder}
+            maxLength={MAX_OPTION_LABEL_LENGTH}
+            value={ownText}
+            onFocus={chooseOwn}
+            onChange={(event) => {
+              setOwnText(event.target.value);
+              chooseOwn();
+            }}
+          />
+        </label>
+      </div>
+      <input
+        className="sc-input"
+        placeholder={words.decisions.notePlaceholder}
+        maxLength={MAX_NOTE_LENGTH}
+        value={note}
+        onChange={(event) => setNote(event.target.value)}
+      />
+      <div className="sc-form-actions">
+        <Button
+          type="submit"
+          variant="primary"
+          size="sm"
+          disabled={answer === undefined || props.busy === true}
+        >
+          {words.decisions.answer}
+        </Button>
+      </div>
+    </form>
+  );
+}
+
 /** What followed the decision: shown, and written or changed by whoever may. */
 function Outcome(props: {
   readonly decision: RestDecision;
@@ -109,11 +235,7 @@ function Outcome(props: {
 export function DecisionCard(props: DecisionCardProps) {
   const words = useWords();
   const { decision, task } = props;
-  const [chosen, setChosen] = useState<string | undefined>(undefined);
-  const [note, setNote] = useState("");
   const answered = decision.answer !== null;
-  const chosenLabel = (id: string) =>
-    decision.options.find((option) => option.id === id)?.label ?? id;
 
   return (
     <article id={decision.id} className={cx("sc-decision", answered && "sc-decision-answered")}>
@@ -126,11 +248,7 @@ export function DecisionCard(props: DecisionCardProps) {
           )}
         </h3>
         <p className="sc-decision-meta">
-          <PersonChip person={decision.raisedBy} />{" "}
-          {decision.run === null
-            ? words.decisions.asked
-            : words.decisions.askedThrough(agentLabel(decision.run.agent))}{" "}
-          <Time iso={decision.createdAt} />
+          <Asked decision={decision} />
           {task !== undefined && (
             <>
               {" "}
@@ -156,7 +274,9 @@ export function DecisionCard(props: DecisionCardProps) {
       )}
       {decision.answer !== null ? (
         <div className="sc-answer">
-          <p className="sc-answer-option">{chosenLabel(decision.answer.option)}</p>
+          <p className="sc-answer-option">
+            <Chosen decision={decision} />
+          </p>
           {decision.answer.note !== null && (
             <div className="sc-answer-note">
               <Markdown source={decision.answer.note} docHref={props.docHref} />
@@ -170,53 +290,7 @@ export function DecisionCard(props: DecisionCardProps) {
       ) : props.onAnswer === undefined ? (
         <p className="sc-decision-waiting">{words.decisions.waitingForPerson}</p>
       ) : (
-        <form
-          className="sc-answer-form"
-          onSubmit={(event) => {
-            event.preventDefault();
-            if (chosen !== undefined) {
-              props.onAnswer?.(decision, {
-                option: chosen,
-                ...(note.trim() === "" ? {} : { note: note.trim() }),
-              });
-            }
-          }}
-        >
-          <div className="sc-options-list" role="radiogroup" aria-label={words.decisions.options}>
-            {decision.options.map((option) => (
-              <label
-                key={option.id}
-                className={cx("sc-option", chosen === option.id && "sc-option-chosen")}
-              >
-                <input
-                  type="radio"
-                  name={`decision-${decision.id}`}
-                  value={option.id}
-                  checked={chosen === option.id}
-                  onChange={() => setChosen(option.id)}
-                />
-                <span>{option.label}</span>
-              </label>
-            ))}
-          </div>
-          <input
-            className="sc-input"
-            placeholder={words.decisions.notePlaceholder}
-            maxLength={MAX_NOTE_LENGTH}
-            value={note}
-            onChange={(event) => setNote(event.target.value)}
-          />
-          <div className="sc-form-actions">
-            <Button
-              type="submit"
-              variant="primary"
-              size="sm"
-              disabled={chosen === undefined || props.busy === true}
-            >
-              {words.decisions.answer}
-            </Button>
-          </div>
-        </form>
+        <AnswerForm decision={decision} onAnswer={props.onAnswer} busy={props.busy} />
       )}
       {answered && (
         <Outcome
@@ -238,6 +312,9 @@ export interface DecisionListProps {
   readonly docHref?: ((path: string) => string) | undefined;
   /** Where each decision's own page is. */
   readonly decisionHref?: ((decision: RestDecision) => string) | undefined;
+  /** The page of the record shown, from 1, and where each page is (ADR-0010); left out, the record turns its pages in place. */
+  readonly page?: number | undefined;
+  readonly pageHref?: ((page: number) => string) | undefined;
   readonly onAnswer?: ((decision: RestDecision, input: RestAnswerInput) => void) | undefined;
   readonly onUpdate?: ((decision: RestDecision, patch: RestDecisionPatch) => void) | undefined;
   readonly busy?: boolean | undefined;
@@ -251,48 +328,101 @@ export interface DecisionLogProps {
   readonly taskHref?: ((task: RestTask) => string) | undefined;
   /** Where each decision's own page is, with its context, its rationale and what followed. */
   readonly decisionHref?: ((decision: RestDecision) => string) | undefined;
+  /** Where a document the word given with an answer links to is read, by its path. */
+  readonly docHref?: ((path: string) => string) | undefined;
+  /** The page shown, from 1; the first when left out, the last for one past the end. Read with `pageHref`. */
+  readonly page?: number | undefined;
+  /** Where each page of the record is, so that a page has an address; left out, the pages turn in place. */
+  readonly pageHref?: ((page: number) => string) | undefined;
 }
 
-/** The record: one row per decision answered, what was asked, what was chosen, by whom, when. */
+/** One row of the record: what was asked, by whom and when; what was answered, with the word given, by whom and when. */
+function RecordRow(props: {
+  readonly decision: RestDecision;
+  readonly task: RestTask | undefined;
+  readonly taskHref: ((task: RestTask) => string) | undefined;
+  readonly href: string | undefined;
+  readonly docHref: ((path: string) => string) | undefined;
+}) {
+  const words = useWords();
+  const { decision, task } = props;
+  const { answer } = decision;
+  return (
+    <li className="sc-decision-record-row">
+      <div className="sc-decision-record-asked">
+        <p className="sc-decision-record-question">
+          {props.href === undefined ? (
+            decision.question
+          ) : (
+            <a href={props.href}>{decision.question}</a>
+          )}
+          {task !== undefined &&
+            (props.taskHref === undefined ? (
+              <span className="sc-card-number">#{task.number}</span>
+            ) : (
+              <a className="sc-card-number" href={props.taskHref(task)}>
+                #{task.number}
+              </a>
+            ))}
+        </p>
+        <p className="sc-decision-record-meta">
+          <Asked decision={decision} day />
+        </p>
+      </div>
+      {answer !== null && (
+        <div className="sc-decision-record-answer">
+          <p className="sc-decision-record-chosen">
+            <Chosen decision={decision} />
+          </p>
+          {answer.note !== null && (
+            <div className="sc-decision-record-note">
+              <Markdown source={answer.note} docHref={props.docHref} />
+            </div>
+          )}
+          <p className="sc-decision-record-meta">
+            <PersonChip person={answer.by} /> {words.decisions.answeredBy}{" "}
+            <Time iso={answer.at} precision="day" />
+          </p>
+        </div>
+      )}
+    </li>
+  );
+}
+
+/**
+ * The record: one row per decision answered, what was asked and by whom, what was chosen with
+ * the word given and by whom; twenty to a page, the page named by the address or turned here.
+ */
 export function DecisionLog(props: DecisionLogProps) {
   const words = useWords();
-  const { shown, rest, more } = usePaged(props.decisions);
+  const [turned, setTurned] = useState(1);
+  const { shown, page, pages } = pageOf(
+    props.decisions,
+    props.pageHref === undefined ? turned : props.page,
+    RECORD_PAGE_SIZE,
+  );
   return (
     <>
-      <ol className="sc-decision-log" aria-label={words.decisions.record}>
-        {shown.map((decision) => {
-          const task = decision.taskId === null ? undefined : props.tasks?.get(decision.taskId);
-          const href = props.decisionHref?.(decision);
-          const chosen =
-            decision.options.find((option) => option.id === decision.answer?.option)?.label ??
-            decision.answer?.option ??
-            "";
-          return (
-            <li key={decision.id} className="sc-decision-row">
-              <span className="sc-decision-row-question">
-                {href === undefined ? decision.question : <a href={href}>{decision.question}</a>}
-              </span>
-              <span className="sc-decision-row-answer">{chosen}</span>
-              <span className="sc-decision-row-meta">
-                {decision.answer !== null && (
-                  <>
-                    <PersonChip person={decision.answer.by} /> <Time iso={decision.answer.at} />
-                  </>
-                )}
-                {task !== undefined &&
-                  (props.taskHref === undefined ? (
-                    <span className="sc-card-number">#{task.number}</span>
-                  ) : (
-                    <a className="sc-card-number" href={props.taskHref(task)}>
-                      #{task.number}
-                    </a>
-                  ))}
-              </span>
-            </li>
-          );
-        })}
+      <ol className="sc-decision-record" aria-label={words.decisions.record}>
+        {shown.map((decision) => (
+          <RecordRow
+            key={decision.id}
+            decision={decision}
+            task={decision.taskId === null ? undefined : props.tasks?.get(decision.taskId)}
+            taskHref={props.taskHref}
+            href={props.decisionHref?.(decision)}
+            docHref={props.docHref}
+          />
+        ))}
       </ol>
-      <ShowMore rest={rest} onMore={more} />
+      <Pager
+        page={page}
+        pages={pages}
+        total={props.decisions.length}
+        pageSize={RECORD_PAGE_SIZE}
+        pageHref={props.pageHref}
+        onPage={setTurned}
+      />
     </>
   );
 }
@@ -332,6 +462,9 @@ export function DecisionList(props: DecisionListProps) {
             tasks={props.tasks}
             taskHref={props.taskHref}
             decisionHref={props.decisionHref}
+            docHref={props.docHref}
+            page={props.page}
+            pageHref={props.pageHref}
           />
         </section>
       )}

package/src/components/event-feed.tsx

@@ -46,6 +46,8 @@ export function describeEvent(event: RestEvent, words: Messages = en): string {
       return feed.event.personDeactivated(login);
     case "person.reactivated":
       return feed.event.personReactivated(login);
+    case "workspace.updated":
+      return feed.event.workspaceUpdated(fields);
     case "project.created":
       return feed.event.projectCreated(project);
     case "project.updated":