File size: 33,653 Bytes
e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 3e19b1e e88a3a3 cfa8541 e88a3a3 3e19b1e e88a3a3 cfa8541 e88a3a3 a83fcff e88a3a3 85f794d a83fcff e88a3a3 cfa8541 e88a3a3 a83fcff e88a3a3 85f794d e88a3a3 85f794d e88a3a3 a83fcff e88a3a3 cfa8541 e88a3a3 cfa8541 e88a3a3 3e19b1e 85f794d e88a3a3 a83fcff 3e19b1e a83fcff 3e19b1e e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 3e19b1e e88a3a3 3e19b1e e88a3a3 cfa8541 e88a3a3 a83fcff e88a3a3 85f794d e88a3a3 85f794d e88a3a3 85f794d e88a3a3 3e19b1e e88a3a3 85f794d 3e19b1e 85f794d e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 85f794d e88a3a3 85f794d e88a3a3 85f794d e88a3a3 3e19b1e e88a3a3 85f794d e88a3a3 85f794d e88a3a3 3e19b1e e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 a83fcff e88a3a3 3e19b1e e88a3a3 a83fcff e88a3a3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 | // ---------------------------------------------------------------------------
// shell/ShareDialog.tsx β WAVE 20 items 18 / 23 / 26 (R10, contract C-SHARE):
// ONE dialog that shares a view, a folder or a database, and edits who already
// has it.
//
// ONE dialog for three kinds is the ruling, not a convenience: R10 says folders
// and databases share "with the SAME two-role vocabulary views use". Three
// dialogs would drift into three vocabularies within a wave.
//
// It renders over the ALREADY-LOADED state and decides nothing itself β every
// rule (what a junk entry means, who may administer, what the PUT carries) is in
// `shareModel.ts`, where the access gate can run it.
// ---------------------------------------------------------------------------
import { useCallback, useEffect, useRef, useState } from "react";
import { API_V1, CREDENTIALS } from "../apiContract";
import PublishPanel from "../publish/PublishPanel";
import { useEscapeClose } from "../ui/useEscapeClose";
import {
EVERYONE,
EVERYONE_LABEL,
SHARE_ROLES,
addablePeople,
parseShare,
resolveShareRecipient,
shareAccessStatus,
sharePutBody,
withEntry,
withoutEntry,
} from "./shareModel";
import type { ShareEntry, ShareKind, ShareRole, ShareState } from "./shareModel";
/**
* ββ W39-T17 β THIS MAP DOES NOT DEGRADE, IT PRINTS THE WORD `undefined`. A kind with no entry
* renders "Share undefined" in the heading AND "no longer has this undefined" in the revoke toast:
* two live strings, not one. `Record<ShareKind, string>` is what stops that being a discovery β
* add a member to `SHARE_KINDS` without one here and `tsc` names this line.
*/
const KIND_WORD: Record<ShareKind, string> = {
view: "view",
folder: "folder",
database: "database",
field: "field",
workbook: "workbook",
report: "report",
};
// A newly-created field is posted through the standalone event queue. The
// share dialog can open before that POST reaches the API, so give field lookups
// a short, bounded chance to observe the definition before showing a 404.
//
// W50-T23 KEPT THIS DELIBERATELY, AND THE SERVER CHANGE IS WHAT SCOPED IT.
// `GET /share/field/...` used to answer 404 for two different situations: a
// column that does not exist yet (the create race above) and a column that
// exists but is not this account's, which is far commoner. The route now
// answers the second one with a 403 that names the column and its owner, so a
// 404 on this kind means only "no definition in any stratum" -- which is the
// race, and the one thing waiting can actually fix. Deleting the loop would
// take the guard away from the race it was written for; the retry is now bounded
// to that race by what the server can still answer, not by a client-side flag.
const FIELD_SHARE_RETRY_MS = [150, 300, 600, 1000] as const;
/** What each role MEANS on each kind, in the reader's own terms. A role picker
* whose options are two nouns makes the reader guess; these sentences describe
* the effective capability at the point where the role is chosen. */
const ROLE_BLURB: Record<ShareKind, Record<ShareRole, string>> = {
view: {
view: "Can open this view. Cannot rename, refilter or delete it.",
edit: "Can change this view's filters, sorts and columns, then share it with other people.",
},
folder: {
view: "Can open the folder and the views inside it.",
edit: "Can rename the folder and move views in and out of it.",
},
database: {
view: "Can open this database and read its records.",
edit: "Can add, edit and delete its records.",
},
field: {
view: "Can see this column. Cannot change its values or field settings.",
edit: "Can change this column's values and field settings when the view is editable.",
},
/* R16, and the wording tracks the picker: a workbook's view role reads "View only", so the
sentence under it says what "only" leaves out rather than restating the label. */
workbook: {
view: "View only: can open this workbook and read every sheet in it. Cannot change a cell, a formula or a binding.",
edit: "Can change this workbook's cells, formulas and bindings.",
},
report: {
view: "Can download this report.",
edit: "Reports cannot be edited.",
},
};
/**
* ββ W51-T10 / R16 β WHAT A WORKBOOK SHARE ACTUALLY HANDS OVER, AND THE HALF NOBODY EXPECTS.
* A workbook's cells are not all values: a bound cell is a QUERY, and it is run again under
* whoever is reading. So two people can open one shared workbook and honestly see two different
* numbers, and the person doing the sharing has to be told that before they share.
*
* β A `const`, NOT INLINE JSX, FOR THE REASON THIS FILE ALREADY RECORDS TWICE: `verify_prose`'s
* JSX pass skips any run containing a newline, and a pinning regex cannot span a prettier line
* wrap. `verify_wiring.py`'s W51-T10 section matches this literal.
*
* β IT RENDERS ABOVE THE ROLE PICKER RATHER THAN INSIDE IT. The picker's blurb only paints once
* the GET has answered, and the workbook share routes do not exist yet, so a sentence that lived
* there alone would be absent in the only case that exists today.
*/
const WORKBOOK_BOUND_CELLS =
"Bound cells show what each person may see: every bound cell is read again under the reader's own scope, so one workbook can honestly show two people different numbers.";
/**
* ββ THE DEGRADE, AND IT IS KEYED ON A RANGE RATHER THAN ON A LIST OF CODES. `GET
* /share/workbook/{id}` sits under a `/{kind}/{oid}` path param, so an id this account cannot
* reach answers 404 while a shape the server dislikes can surface as 400, 405 or 500. A code
* list would miss the very answer the server actually gives, and the reader would get the
* generic "The server answered 405." instead: a status number, which is not a sentence and
* tells them nothing they can act on. 403 stays on the ordinary path, because "you may not" is
* a real answer about a route that exists.
*
* β THE SENTENCE CHANGED AT THE WAVE-51 GO-LIVE QA, AND THE OLD ONE WAS THE DEFECT.
* It read *"Workbook sharing is still being built"*, which was true when W51-T10 shipped
* against an unbuilt server half and FALSE the moment W51-T25 landed beside it in the combine.
* The QA pass then found the real cause: `routes_shares.py::_owns_object` carried no
* `workbook` branch, so the owner of an unshared workbook was answered `404 no_object` and this
* copy explained a shipped feature away as unbuilt. The branch exists now; this string is the
* ordinary degrade for a workbook that genuinely cannot be reached, and it no longer makes a
* claim about the product's roadmap that only a code reader could falsify.
* β NO EM DASH AND NO EN DASH: this reaches a screen (standing rule 2).
*/
const WORKBOOK_SHARE_UNREACHABLE =
"This workbook's sharing list could not be loaded. Close and reopen the dialog; if it keeps failing, the workbook may have been deleted, or it may no longer be yours to share.";
/**
* ββ W42-T26 (owner instruction 8, R9, contract C7) β THE SHARER IS TOLD WHICH FIELDS TRAVEL.
* Sharing a view grants every field the view NAMES, and until this landed the dialog said nothing
* about fields at all. The trap the ticket names: T25 makes the behaviour correct and nothing on
* screen changes, so the disclosure is the half that gets dropped.
*
* β THESE ARE CONSTANTS, NOT INLINE JSX TEXT, FOR TWO REASONS. (1) `verify_prose`'s JSX pass skips
* any run containing a newline [[web-prose-blind-to-wrapped-jsx]], and this file's own comments
* record that blind spot twice; a `const` string literal is seen by the gate whatever prettier does
* to the markup around it. (2) `wiring_rows/wave42_g.py` pins this copy by regex, and a regex
* cannot span a JSX line wrap. Standing rule 2: no em dash and no en dash below.
*/
const VIEW_FIELD_TRAVEL =
"Sharing a view also shares the fields it uses: the columns it shows, and the columns it groups by, colors by and sorts by.";
/** β ITS OWN SENTENCE ON PURPOSE, and the non-obvious half of the disclosure. A sharer reasons
* about the columns they can SEE; a condition may name one they never put on screen, and the
* grant covers it all the same. The done-when calls this clause out separately, so it has to be
* readable on its own rather than being a word inside a list.
* β Do NOT restate the literal below in prose here: `wave42_g.py` pins it, and the WIRINGS loop
* matches raw file text (comments included), so a paraphrase close enough to match would let the
* row pass off its own explanation. */
const VIEW_FILTER_FIELDS =
"The filters count too. A filter can test a column that is not on screen, and sharing this view hands that column over as well.";
/** β The grant is TOPIC-WIDE by construction (C7), so the dialog has to say so in the reader's
* terms rather than let them assume it stops at this view. */
const VIEW_FIELD_TOPIC_WIDE =
"Each of those fields then shows on every view of this database, not only on this one.";
const VIEW_EDITOR_REDISTRIBUTION =
"People with Can edit may share this View with others. They may include any field they can read.";
export default function ShareDialog({
kind,
id,
label,
topic,
me,
onClose,
onToast,
}: {
kind: ShareKind;
id: string;
label: string;
/**
* β W33-T27 (item 8b, R5) β the DATABASE a shared VIEW belongs to, so the publish control can
* address it as `(topic, view)`. Empty for a folder or a database share, and empty is honest:
* the panel simply does not render, which is also what happens on a view the server refuses to
* publish. β Supplied by `Shell` at the mount (`shareModel.ShareRequest.topic`), not by this
* dialog β see that field's note for why it is optional and how the mount is asserted.
*/
topic?: string;
/** The signed-in account's username, so the reader recognises themselves in the
* list. `people` is deliberately the OTHER accounts (it is the add-picker's
* source), so without this the owner row prints a raw login where every other
* row prints a name. */
me: string;
onClose: () => void;
onToast: (message: string) => void;
}) {
const [state, setState] = useState<ShareState | null>(null);
const [entries, setEntries] = useState<ShareEntry[]>([]);
const [error, setError] = useState("");
const [busy, setBusy] = useState(false);
const [recipientQuery, setRecipientQuery] = useState("");
const [pickRole, setPickRole] = useState<ShareRole>("view");
// The shared parser drops response extensions, so retain the server ceiling separately.
const [maxGrantableRole, setMaxGrantableRole] = useState<ShareRole | null>(null);
const dialogRef = useRef<HTMLDivElement>(null);
const focusReturnRef = useRef<HTMLElement | null>(null);
// W50-T23 / R7 -- the owner in the words a person reads, resolved by the server
// through the account registry, with "System (Odoo)" standing in for a column
// the connector wrote. `parseShare` builds a fixed five-key object and drops
// everything else, so this display-only label rides off the raw body.
const [ownerLabel, setOwnerLabel] = useState("");
const path = `${API_V1}/share/${encodeURIComponent(kind)}/${encodeURIComponent(id)}`;
useEffect(() => {
focusReturnRef.current = document.activeElement instanceof HTMLElement
? document.activeElement
: null;
dialogRef.current?.focus();
return () => {
const opener = focusReturnRef.current;
if (opener?.isConnected) opener.focus();
};
}, []);
useEffect(() => {
let dead = false;
setState(null);
setMaxGrantableRole(null);
setPickRole("view");
setError("");
void (async () => {
try {
let res: Response;
for (let attempt = 0; ; attempt += 1) {
res = await fetch(path, { credentials: CREDENTIALS });
if (
res.status !== 404 ||
kind !== "field" ||
attempt >= FIELD_SHARE_RETRY_MS.length
) {
break;
}
await new Promise<void>((resolve) => {
window.setTimeout(resolve, FIELD_SHARE_RETRY_MS[attempt]);
});
if (dead) return;
}
if (!res.ok) {
// W51-T10: a workbook the server will not answer for. A sentence, never a status
// number, and never a blank dialog. See `WORKBOOK_SHARE_UNREACHABLE` for why the
// test is a RANGE rather than a code list.
if (kind === "workbook" && res.status >= 400 && res.status !== 403) {
if (!dead) setError(WORKBOOK_SHARE_UNREACHABLE);
return;
}
// 4xx text is policy the reader needs; a 5xx's internals are not theirs.
if (!dead) setError(res.status >= 500
? "Something went wrong on our side. Try again in a moment."
: `The server answered ${res.status}.`);
return;
}
const body = (await res.json().catch(() => null)) as unknown;
if (dead) return;
const parsed = parseShare(body);
const ceiling = body && typeof body === "object"
? (body as { maxGrantableRole?: unknown }).maxGrantableRole
: null;
setMaxGrantableRole(ceiling === "view" || ceiling === "edit" ? ceiling : null);
setState(parsed);
setEntries(parsed.entries);
setOwnerLabel(
body && typeof body === "object"
&& typeof (body as { ownerLabel?: unknown }).ownerLabel === "string"
? ((body as { ownerLabel?: string }).ownerLabel ?? "").trim()
: ""
);
} catch {
if (!dead) setError("Cannot reach the server.");
}
})();
return () => {
dead = true;
};
}, [path]);
// The Share modal joins the one overlay stack. A local key listener races any picker or
// nested publish control mounted inside it and can close two surfaces from one Escape.
useEscapeClose(true, () => {
if (!busy) onClose();
}, { container: () => dialogRef.current });
const save = useCallback(
async (next: ShareEntry[]) => {
setBusy(true);
setError("");
try {
const res = await fetch(path, {
method: "PUT",
credentials: CREDENTIALS,
headers: { "Content-Type": "application/json" },
// The WHOLE list, every time: the PUT replaces, so a body assembled from
// a delta would revoke everyone it failed to mention.
body: JSON.stringify(sharePutBody(next)),
});
if (!res.ok) {
const body = (await res.json().catch(() => null)) as
| { error?: { code?: string; message?: string } }
| null;
setError(
res.status >= 500 && body?.error?.code !== "view_share_failed"
? "Something went wrong on our side. Try again in a moment."
: body?.error?.message || `The server answered ${res.status}.`
);
return false;
}
const body = (await res.json().catch(() => null)) as unknown;
// Re-read the SERVER's copy rather than trusting the draft: `_clean_entries`
// drops what it will not store, and an editor that kept showing a row the
// store rejected would be the "shared, silently inert" failure this feature
// exists to avoid.
// β Only `.entries` is consumed here β the PUT answers with the stored record
// (`{owner, entries}`) and says nothing about this session's standing, so the
// literal below feeds the parser's required field and is never read back. The
// editor's `mayAdminister` stays the one the GET established; a save cannot
// promote anybody, and this line must never be the reason it looks like it can.
const saved = parseShare({ ...(body as object), mayAdminister: true });
setEntries(saved.entries);
return true;
} catch {
setError("Cannot reach the server.");
return false;
} finally {
setBusy(false);
}
},
[path]
);
const mayAdminister = !!state?.mayAdminister;
const grantableRoles = SHARE_ROLES.filter((role) => mayAdminister && (kind !== "report" || role === "view") && (
maxGrantableRole === "edit" || (maxGrantableRole === "view" && role === "view")
));
const assign = useCallback(async (user: string) => {
setBusy(true); setError("");
try {
const res = await fetch(`${path}/assign`, {
method: "POST", credentials: CREDENTIALS,
headers: { "Content-Type": "application/json" }, body: JSON.stringify({ user }),
});
if (!res.ok) { setError(`The server answered ${res.status}.`); return; }
onToast(`${nameOf(user)} now has this assigned view.`);
} catch { setError("Cannot reach the server."); }
finally { setBusy(false); }
}, [path, onToast]);
const options = state ? addablePeople(state.people, entries) : [];
const pick = state
? kind === "report"
? resolveShareRecipient(state.people, entries, recipientQuery, kind)
: resolveShareRecipient(state.people, entries, recipientQuery)
: null;
const canAddEveryone = kind !== "report" && !entries.some((entry) => entry.user === EVERYONE);
const nameOf = (user: string) =>
user === "*"
? "Everyone"
: user && user === me.trim().toLowerCase()
? "You"
: state?.people.find((p) => p.user === user)?.name ?? user;
return (
<div className="shell-newdb-scrim">
<div
ref={dialogRef}
className="shell-newdb shell-share"
role="dialog"
aria-modal="true"
aria-label={`Share ${label}`}
tabIndex={-1}
onClick={(e) => e.stopPropagation()}
>
<h2>Share {KIND_WORD[kind]}</h2>
{/* ββ W33-T30 / audit S-8 β THIS SENTENCE WAS FALSE FOR ONE OF THE THREE KINDS.
It read, unconditionally, "Sharing never widens past this workspace: everyone here
can already open the surface it lives on." True for a VIEW or a FOLDER on a governed
module, where the receiver's row scope and hidden-field closure run before any
foreign view is merged. FALSE for a `database` grant on a `ut_*` table: no row filter
and no hidden field can even be DECLARED there (`_PERM_MODULES` is two keys and
`_clean_perms` 400s the rest), so the grant registry IS the only wall and the grant
is all-or-nothing. The audit's fix is "say so at BOTH doors"; `core/shares.py` and
`routes_shares.py` are the other two, and this is the one a PERSON reads. */}
{/* β STANDING RULE 2 (D-490, W39-T17) β THIS LINE CARRIED AN EM DASH TO THE SCREEN AND
`verify_prose.py` SCORED THE FILE ZERO. The prose run WRAPS, and the gate's JSX pass
skips any run containing a newline [[web-prose-blind-to-wrapped-jsx]] β the same blind
spot already recorded twenty lines below. REWRITTEN, not stripped: the question the
dialog answers is now the sentence's subject, which needs no dash at all. */}
<p className="shell-newdb-sub">
{kind !== "report" ? <>Who can reach <strong>{label}</strong>, and what they can do with it.{" "}</> : null}
{kind === "workbook"
? WORKBOOK_BOUND_CELLS
: kind === "database"
? "Sharing a database shares all of it: every record and every column. There is no per-row or per-column limit on a database grant."
: kind === "field"
? "A shared column starts out hidden from everybody else on this database. This is what lets the people you choose see it and its values."
: kind === "report"
? "Only the people you add here see this report."
: "Sharing never widens past this workspace: everyone here can already open the surface it lives on."}
</p>
{kind === "view" ? (
<>
<p className="shell-share-note">
View access is the general rule. A field's own Share field access takes precedence, so
a field shared as Can view stays read-only even inside an editable view.
</p>
{/* ββ W42-T26 / C7 β WHICH FIELDS TRAVEL, and how far. Two paragraphs, not one and
not four: the done-when reads for three statements (what travels, the FILTER's
fields by name, and the topic-wide reach), and a sharer must be able to point at a
sentence for each without reading an essay in a dialog subtitle. */}
<p className="shell-share-note">
{VIEW_FIELD_TRAVEL} {VIEW_FIELD_TOPIC_WIDE}
</p>
<p className="shell-share-note">{VIEW_FILTER_FIELDS}</p>
<p className="shell-share-note">{VIEW_EDITOR_REDISTRIBUTION}</p>
</>
) : kind === "field" ? (
<p className="shell-share-note">
Field access takes precedence over the view. Can view keeps values and field settings
read-only; Can edit allows changes when the view is editable.
</p>
) : null}
{!state && !error ? (
<div className="shell-share-wait">
<span className="lp-spin" role="status" aria-label="Loading" />
</div>
) : null}
{state ? (
<>
{/* THE MANAGE-ACCESS EDITOR (item 23): the list first, because the
question people open this for is "who has this already" β with the
one-line answer above it, since the fact that changes everything
("Everyone can edit") is the one a list of rows buries. */}
<h3 className="shell-share-summary">Manage access</h3>
<p className="shell-share-note">
Workspace access: {shareAccessStatus(entries)}.
</p>
<div className="shell-share-list">
{/* W50-T23 / R7 -- THE OWNER ROW IS NEVER BLANK AND NEVER ABSENT. Under R7
every editable field has an owner (its creator, else the tenant
Administrator) and a connector column reads "System (Odoo)", so there is
always something true to print. The old `: null` arm rendered NOTHING for
a column whose owner the server could not name, which is how a member
ended up being told to ask somebody the dialog never showed them.
`ownerLabel` is preferred over `nameOf` only when `nameOf` could not
resolve the username: a member gets `people: []`, so `nameOf` would print
a raw login where the server already knows the real name. */}
{state.owner || (kind === "field" && ownerLabel) ? (
<div className="shell-share-row is-owner">
<span className="shell-share-who">
{state.owner
? nameOf(state.owner) === state.owner
? ownerLabel || state.owner
: nameOf(state.owner)
: ownerLabel}
</span>
<span className="shell-share-role">Owner</span>
</div>
) : null}
{entries.length === 0 ? (
<div className="shell-share-empty">
Not shared with anyone yet.
</div>
) : null}
{entries.map((e) => (
<div className="shell-share-row" key={e.user}>
<span className="shell-share-who">{nameOf(e.user)}</span>
{grantableRoles.includes(e.role) ? <select
className="shell-share-select"
value={e.role}
disabled={!mayAdminister || busy}
aria-label={`Role for ${nameOf(e.user)}`}
onChange={(ev) => {
const role = ev.target.value as ShareRole;
if (!grantableRoles.includes(role)) return;
const next = withEntry(entries, e.user, role);
void save(next);
}}
>
{/* β W51-T10 / R16 β THE LABEL IS PER KIND, exactly as `KIND_WORD` and
`ROLE_BLURB` are. A workbook's read role is "View only" (the ruling's own
words); the other four kinds keep "Can view" byte for byte, because
re-wording one label across a shared control is a repo-wide gate grep. */}
{grantableRoles.map((r) => (
<option key={r} value={r}>
{r === "edit"
? "Can edit"
: kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
</option>
))}
</select> : (
// Existing grants above the ceiling stay unchanged in every replacing PUT.
<span className="shell-share-role">
{e.role === "edit" ? "Can edit" : kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
</span>
)}
<button
type="button"
className="shell-share-revoke"
disabled={!mayAdminister || busy}
onClick={() => {
const next = withoutEntry(entries, e.user);
void save(next).then((ok) => {
if (ok) onToast(`${nameOf(e.user)} no longer has this ${KIND_WORD[kind]}.`);
});
}}
>
Remove
</button>
{kind === "view" && mayAdminister && e.user !== "*" ? (
<button type="button" className="shell-share-revoke" disabled={busy}
onClick={() => void assign(e.user)}>
Assign
</button>
) : null}
</div>
))}
</div>
{mayAdminister ? (
<div className="shell-share-add">
<input
className="shell-share-select"
type="search"
list="shell-share-recipient-options"
value={recipientQuery}
disabled={busy}
aria-label="Search people to share with"
placeholder="Search people"
autoFocus
onChange={(e) => setRecipientQuery(e.target.value)}
/>
<datalist id="shell-share-recipient-options">
{canAddEveryone ? <option value={EVERYONE_LABEL} /> : null}
{options.map((p) => (
<option key={p.user} value={`${p.name} (${p.user})`} />
))}
</datalist>
<select
className="shell-share-select"
value={pickRole}
disabled={busy || !grantableRoles.length}
aria-label="Role for the person being added"
onChange={(e) => {
const role = e.target.value as ShareRole;
if (grantableRoles.includes(role)) setPickRole(role);
}}
>
{/* The add-person picker says the same words the row picker says. */}
{grantableRoles.map((r) => (
<option key={r} value={r}>
{r === "edit"
? "Can edit"
: kind === "report" ? "Can download" : kind === "workbook" ? "View only" : "Can view"}
</option>
))}
</select>
<button
type="button"
className="login-submit shell-share-grant"
disabled={busy || !pick || !grantableRoles.includes(pickRole)}
onClick={() => {
if (!pick || !grantableRoles.includes(pickRole)) return;
const next = withEntry(entries, pick, pickRole);
void save(next).then((ok) => {
if (ok) {
onToast(
kind === "field"
? `${nameOf(pick)} can now ${pickRole === "edit" ? "edit" : "view"} this field.`
: kind === "report"
? `${nameOf(pick)} can now download this report.`
: `${nameOf(pick)} can now ${pickRole} this ${KIND_WORD[kind]}.`
);
setRecipientQuery("");
}
});
}}
>
Send
</button>
<p className="shell-share-blurb">{ROLE_BLURB[kind][pickRole]}</p>
{/* β W33-T30 / audit S-5 β `*` + `edit` IS A TENANT-WIDE WRITE GRANT AND LOOKED
LIKE ANY OTHER ROW. Two ordinary choices β a population and a role, each
unremarkable alone β combine into "anybody here may change this", and the
dialog said nothing at the point where the two meet. The audit's fix is
"make the population legible at the point of choice": one sentence, only on
the combination, in the words of the consequence rather than of the setting.
β It is NOT a confirm step. The capability is real and deliberate; a person
choosing it on purpose should not be interrogated, only told what it means. */}
{/* β `shell-share-note`, the class the refusal below already uses, rather than a
new `shell-share-warn`: `index.css` is B's file this wave (contract C4), and a
new class with no rule renders as unstyled body text β which for a sentence
whose whole job is to be NOTICED is worse than reusing a quiet one. */}
{/* β STANDING RULE 2 (wave-36 QA) β the sentence below carried an em dash and
`web_prose` scored this file 0 findings: the prose run WRAPS, and the gate's
JSX pass skips any run containing a newline [[web-prose-blind-to-wrapped-jsx]].
REWRITTEN, not merely stripped β the comma keeps the contrast the sentence
exists to draw. */}
{pick === EVERYONE && pickRole === "edit" ? (
<p className="shell-share-note">
Everyone in this workspace will be able to change this {KIND_WORD[kind]},
not just open it.
</p>
) : null}
</div>
) : (
// β NOT A HIDDEN EDITOR β a stated refusal. A collaborator who can
// change this object's CONTENT still cannot change who else reaches
// it (the server's rule; this is the courtesy half). Saying why beats
// greying three controls and letting the reader guess.
// β STANDING RULE 2 (W39-T17) β TWO em dashes, live on screen, and `verify_prose`
// green over both for the wrapped-JSX reason recorded above. NOT a pre-existing
// violation this ticket may leave alone: adding `field` to `KIND_WORD` is what
// brings this sentence to a NEW surface, so it ships the dash rather than merely
// inheriting it. Rewritten with the owner in the subject, so no aside is needed.
<p className="shell-share-note">
{kind === "report"
? "Only workspace administrators can change who this report is shared with."
: <>Only this {KIND_WORD[kind]}'s owner and workspace administrators can change who
it is shared with. You can still use it as your role allows.</>}
</p>
)}
</>
) : null}
{/* ββ W33-T27 (item 8b, R5) β PUBLISH, below the grant editor and inside the same
dialog, because this is where a person comes to ask "who can reach this?".
β IT IS NOT A FOURTH ROLE IN THE LIST ABOVE, and the panel says so in its own
words: a published link names nobody, creates no grant and is revoked by replacing
the link rather than by removing a person. Folding it into the entries list would
have made "the public" look like a grantee β which is precisely the conflation the
sharing audit's S-4 row is about (two systems already answer "is this shared"; this
is a third thing).
β ONLY FOR A VIEW, and only when the shell knew which database it belongs to. The
panel then asks the SERVER whether this particular view may be published and renders
nothing if not β so "absent on non-interface views" is one evaluator, not two. */}
{kind === "view" && topic ? <PublishPanel topic={topic} view={id} /> : null}
{error ? <p className="shell-newdb-err" role="alert">{error}</p> : null}
<div className="shell-newdb-actions">
<button type="button" disabled={busy} onClick={onClose}>Close</button>
</div>
</div>
</div>
);
}
|