Spaces:
Paused
Paused
Download web/src/shell/NavExtras.tsx from aios-loopable/cfo-os: direct link, hf CLI and curl.
- Browser
- Download file 36.4 kB
-
https://huggingface.co/spaces/aios-loopable/cfo-os/resolve/main/web/src/shell/NavExtras.tsx
- Command line
-
hf download hf://spaces/aios-loopable/cfo-os/web/src/shell/NavExtras.tsx
-
curl -L -o NavExtras.tsx https://huggingface.co/spaces/aios-loopable/cfo-os/resolve/main/web/src/shell/NavExtras.tsx
36.4 kB
| // --------------------------------------------------------------------------- | |
| // shell/NavExtras.tsx — C-SCHEMA (wave 2026-08-02): the database list's | |
| // three-dots menu, folder heads, and the schema drawer. | |
| // | |
| // Kept out of Shell.tsx so the shell's frame stays readable: Shell owns the | |
| // STATE (prefs, open folders, which schema is open) and the save round-trip; | |
| // these components own only their own popover/drawer chrome. Menus are | |
| // position:fixed against the trigger — the rail scrolls and clips, so an | |
| // absolutely-positioned child could never escape it (the same lesson as the | |
| // collapsed-rail tooltip). | |
| // --------------------------------------------------------------------------- | |
| import { useEffect, useRef, useState } from "react"; | |
| import type { ReactNode } from "react"; | |
| import { fetchSchema } from "./nav"; | |
| import type { NavFolder, SchemaPayload, TableFootprint } from "./nav"; | |
| // ⚠ WAVE 19 R8 / C1 — IMPORTED, NEVER REDEFINED, and the contract says so in as | |
| // many words ("Shapes/tones = the grid's existing vocabulary verbatim (12 | |
| // shapes, 5 tones); B imports, never redefines"). A second copy of this | |
| // vocabulary in the shell is a whitelist that can drift by one member from the | |
| // one the host validates against — and a tone the server does not recognise | |
| // degrades to the default, so the user's choice disappears on reload with | |
| // nothing on screen to say why. These are READ-ONLY imports across the session | |
| // fence: `customer-grid/**` is another session's tree this wave (HARD RULE 3). | |
| import { FolderMark } from "../customer-grid/icons"; | |
| import { FOLDER_SHAPE_LABELS, FOLDER_TONE_LABELS } from "../customer-grid/iconShapes"; | |
| import { | |
| DEFAULT_FOLDER_SHAPE, | |
| DEFAULT_FOLDER_TONE, | |
| FOLDER_SHAPES, | |
| FOLDER_TONES, | |
| } from "../customer-grid/types"; | |
| import type { FolderIcon } from "../customer-grid/types"; | |
| import "./navExtras.css"; | |
| /** | |
| * WAVE 21 item 12 (ruling R11) — HORIZONTAL, and it is the same three dots turned | |
| * 90°, not a different mark. | |
| * | |
| * The rail and the views list are read as one surface, and they were drawing the | |
| * "there is a menu here" affordance two different ways: this glyph stacked its | |
| * circles (cx fixed, cy walking) while `ViewSidebar`'s row buttons have always | |
| * rendered three MIDDLE DOTs on the baseline. Same promise, two pictures — the | |
| * thing R11 names. Only the axis moves: radius, viewBox and the 14px box in | |
| * `navExtras.css` are untouched, so the hit target and the optical weight are | |
| * exactly what shipped. | |
| */ | |
| function DotsIcon() { | |
| return ( | |
| <svg viewBox="0 0 16 16" aria-hidden="true" className="shell-dots-icon"> | |
| <circle cx="3.2" cy="8" r="1.35" /> | |
| <circle cx="8" cy="8" r="1.35" /> | |
| <circle cx="12.8" cy="8" r="1.35" /> | |
| </svg> | |
| ); | |
| } | |
| function FolderIcon() { | |
| return ( | |
| <svg viewBox="0 0 16 16" aria-hidden="true" className="shell-nav-icon"> | |
| <path d="M2.2 4.4c0-.66.54-1.2 1.2-1.2h3l1.4 1.6h4.8c.66 0 1.2.54 1.2 1.2v6c0 .66-.54 1.2-1.2 1.2H3.4c-.66 0-1.2-.54-1.2-1.2z" /> | |
| </svg> | |
| ); | |
| } | |
| /** A fixed-position popover anchored to a trigger rect, closed on outside | |
| * click or Escape. Small on purpose — the shell does not import the grid's | |
| * Popover, so the two chrome trees stay independently deletable. */ | |
| function useMenu() { | |
| const [at, setAt] = useState<{ x: number; y: number } | null>(null); | |
| const ref = useRef<HTMLDivElement>(null); | |
| useEffect(() => { | |
| if (!at) return; | |
| const onDown = (e: MouseEvent) => { | |
| if (ref.current && !ref.current.contains(e.target as Node)) setAt(null); | |
| }; | |
| const onKey = (e: KeyboardEvent) => { | |
| if (e.key === "Escape") setAt(null); | |
| }; | |
| document.addEventListener("mousedown", onDown, true); | |
| document.addEventListener("keydown", onKey, true); | |
| return () => { | |
| document.removeEventListener("mousedown", onDown, true); | |
| document.removeEventListener("keydown", onKey, true); | |
| }; | |
| }, [at]); | |
| const openFrom = (el: HTMLElement) => { | |
| const r = el.getBoundingClientRect(); | |
| setAt({ x: Math.round(r.right + 4), y: Math.round(r.top) }); | |
| }; | |
| return { at, ref, openFrom, close: () => setAt(null) }; | |
| } | |
| function MenuShell({ | |
| at, | |
| menuRef, | |
| wide, | |
| children, | |
| }: { | |
| at: { x: number; y: number }; | |
| menuRef: React.RefObject<HTMLDivElement>; | |
| /** WAVE 21 item 6 — the delete confirm needs prose width; a menu of one-line | |
| * actions does not. The CLAMP moves with the class, because a wider panel | |
| * clamped at the narrow width spills off the right edge on exactly the rows | |
| * furthest from it. */ | |
| wide?: boolean; | |
| children: ReactNode; | |
| }) { | |
| // Clamp to the viewport so a row near the bottom does not spill the menu off it. | |
| const width = wide ? 320 : 248; | |
| const style = { | |
| left: Math.min(at.x, Math.max(8, window.innerWidth - width)), | |
| top: Math.min(at.y, Math.max(8, window.innerHeight - 260)), | |
| }; | |
| return ( | |
| <div | |
| className={"shell-navmenu" + (wide ? " is-wide" : "")} | |
| style={style} | |
| ref={menuRef} | |
| role="menu" | |
| > | |
| {children} | |
| </div> | |
| ); | |
| } | |
| /** | |
| * WAVE 19 R8 / C1 — the 12x5 swatch picker, the grid's own pattern | |
| * (`ViewSidebar.tsx`'s folder form) rendered inside the nav's popover. | |
| * | |
| * TWO ROWS, NOT A GRID OF 60. Shape and tone are independent choices, so the | |
| * shape row previews in the CURRENT tone and the tone row previews in the | |
| * CURRENT shape — every swatch shows what that one click would actually | |
| * produce, which is why picking is one glance rather than a search. | |
| */ | |
| function IconPicker({ | |
| value, | |
| onPick, | |
| onClear, | |
| }: { | |
| value?: FolderIcon; | |
| onPick: (icon: FolderIcon) => void; | |
| /** Absent ⇒ nothing to clear (the row is already on the default mark). */ | |
| onClear?: () => void; | |
| }) { | |
| const shape = value?.shape ?? DEFAULT_FOLDER_SHAPE; | |
| const tone = value?.tone ?? DEFAULT_FOLDER_TONE; | |
| return ( | |
| <div className="shell-navmenu-pick" role="group" aria-label="Database icon"> | |
| <div className="shell-navmenu-pickrow"> | |
| {FOLDER_SHAPES.map((s) => ( | |
| <button | |
| key={s} | |
| type="button" | |
| className={"shell-navmenu-swatch" + (value && shape === s ? " is-on" : "")} | |
| aria-pressed={!!value && shape === s} | |
| aria-label={FOLDER_SHAPE_LABELS[s]} | |
| title={FOLDER_SHAPE_LABELS[s]} | |
| onClick={() => onPick({ shape: s, tone })} | |
| > | |
| <FolderMark icon={{ shape: s, tone }} size={15} /> | |
| </button> | |
| ))} | |
| </div> | |
| <div className="shell-navmenu-pickrow"> | |
| {FOLDER_TONES.map((t) => ( | |
| <button | |
| key={t} | |
| type="button" | |
| className={"shell-navmenu-swatch" + (value && tone === t ? " is-on" : "")} | |
| aria-pressed={!!value && tone === t} | |
| aria-label={FOLDER_TONE_LABELS[t]} | |
| title={FOLDER_TONE_LABELS[t]} | |
| onClick={() => onPick({ shape, tone: t })} | |
| > | |
| <FolderMark icon={{ shape, tone: t }} size={15} /> | |
| </button> | |
| ))} | |
| </div> | |
| {/* ⛔ AN EXPLICIT WAY BACK, because this picker deliberately does NOT copy | |
| `cleanFolderIcon`'s "a fully-default icon is no icon" rule. That rule is | |
| right for a FOLDER, whose default mark IS the folder shape; a database's | |
| default mark is the cylinder, so dropping folder+neutral would answer a | |
| user who picked "Folder" with a picture of a database — the silent | |
| disappearance the tone whitelist's own note warns about. Absent = the | |
| cylinder, chosen = exactly what was chosen, and clearing is a click that | |
| says what it does. */} | |
| {onClear ? ( | |
| <button type="button" className="shell-navmenu-item is-quiet" onClick={onClear}> | |
| Use the default icon | |
| </button> | |
| ) : null} | |
| </div> | |
| ); | |
| } | |
| export function RowMenu({ | |
| entryLabel, | |
| canSchema, | |
| onSchema, | |
| canRename, | |
| onRename, | |
| canIcon, | |
| icon, | |
| onIcon, | |
| onIconClear, | |
| onShare, | |
| canDelete, | |
| onLoadFootprint, | |
| onDelete, | |
| }: { | |
| entryLabel: string; | |
| canSchema: boolean; | |
| onSchema: () => void; | |
| /** | |
| * WAVE 19 R8 — rename is `ut_*` (custom) DATABASES ONLY, and this flag is how | |
| * the row says so. A built-in label is a compiled registry literal: renaming | |
| * `customer_data` would mean the nav and every other reader of | |
| * `core/registry.py` disagreeing about what the module is called. The SERVER | |
| * refuses a `name` for a non-`ut_` key regardless (C1, fail-closed) — this | |
| * only spares the user a control whose write would bounce. | |
| */ | |
| canRename?: boolean; | |
| onRename?: (name: string) => void; | |
| /** Icons ride ALL databases (R8), unlike rename. */ | |
| canIcon?: boolean; | |
| icon?: FolderIcon; | |
| onIcon?: (icon: FolderIcon) => void; | |
| onIconClear?: () => void; | |
| /** WAVE 20 item 18 (C-SHARE) — open the access editor for THIS database. | |
| * Absent = the row does not offer sharing (a group head has nothing to share). */ | |
| onShare?: () => void; | |
| /** | |
| * ⭐ WAVE 21 item 6 (ruling R3, contract C3, wiring W-5) — may this session | |
| * DELETE this database? | |
| * | |
| * ⛔ REQUIRED, NOT OPTIONAL, and that is the wave-20 lesson written into a type. | |
| * Four features shipped dead behind 43 green gates because the prop that carried | |
| * them across an ownership fence was `?`-marked: an unmounted optional prop is | |
| * `undefined`, which reads as "the feature is off" and is indistinguishable from | |
| * "the feature was never built". A required prop makes the unmounted case a | |
| * COMPILE ERROR. The value is the server's (`NavPage.canDelete`), narrower than | |
| * `manage` on purpose — see the note there. | |
| */ | |
| canDelete: boolean; | |
| /** What deleting would destroy. Resolves null when the server would not say — | |
| * the face then asks WITHOUT counts rather than inventing zeros. */ | |
| onLoadFootprint: () => Promise<TableFootprint | null>; | |
| /** Do it. Resolves the server's own words on refusal, which the face shows in | |
| * place of the confirmation — a delete that failed must never look like one | |
| * that worked. */ | |
| onDelete: () => Promise<{ ok: boolean; error?: string }>; | |
| }) { | |
| // Wave 14 C-NAVFOLD (ruling R10): the three-dots kept "View schema" ONLY. | |
| // Wave 19 (R8/C1) adds Rename and Change icon — the first two things a | |
| // database the USER made should have been able to do. | |
| const { at, ref, openFrom, close } = useMenu(); | |
| // Which face the popover is showing. Reset on every open, so a menu that was | |
| // left mid-rename does not reopen into somebody else's half-typed name. | |
| const [mode, setMode] = useState<"menu" | "rename" | "icon" | "delete">("menu"); | |
| const [name, setName] = useState(entryLabel); | |
| /** | |
| * WAVE 21 item 6 — the delete face's own state. `footprint: undefined` means | |
| * "still asking", `null` means "the server would not say" — two different | |
| * things the face words differently, which is why it is not a plain object. | |
| */ | |
| const [del, setDel] = useState<{ | |
| footprint?: TableFootprint | null; | |
| busy: boolean; | |
| error: string; | |
| }>({ busy: false, error: "" }); | |
| const renameOn = !!canRename && !!onRename; | |
| const iconOn = !!canIcon && !!onIcon; | |
| if (!canSchema && !renameOn && !iconOn && !onShare && !canDelete) return null; | |
| const submitRename = () => { | |
| const clean = name.trim().replace(/\s+/g, " "); | |
| if (clean && clean !== entryLabel) onRename?.(clean); | |
| close(); | |
| }; | |
| /** | |
| * ⚠ THE FOOTPRINT IS FETCHED WHEN THE FACE OPENS, NOT WHEN THE MENU DOES. | |
| * Same reasoning as `PermsEditor.prepareCopy` ("the targets are fetched BEFORE | |
| * the confirm"): the question has to name what is being destroyed, and a | |
| * confirm written from the rail's own knowledge can only name the table. The | |
| * cost is paid by the person who clicked Delete, never by everyone who opened | |
| * a menu. | |
| */ | |
| const openDelete = () => { | |
| setDel({ busy: false, error: "" }); | |
| setMode("delete"); | |
| void onLoadFootprint().then((f) => setDel((cur) => ({ ...cur, footprint: f }))); | |
| }; | |
| const runDelete = () => { | |
| setDel((cur) => ({ ...cur, busy: true, error: "" })); | |
| void onDelete().then((r) => { | |
| if (r.ok) { | |
| close(); | |
| setDel({ busy: false, error: "" }); | |
| return; | |
| } | |
| // ⛔ THE MENU STAYS OPEN ON A REFUSAL. Closing it would leave a rail whose | |
| // row is still there and no statement anywhere about why — which reads as | |
| // "the click did nothing" and invites a second one. | |
| setDel((cur) => ({ ...cur, busy: false, error: r.error || "It could not be deleted." })); | |
| }); | |
| }; | |
| return ( | |
| <> | |
| <button | |
| type="button" | |
| className="shell-dots" | |
| aria-label={`Options for ${entryLabel}`} | |
| aria-haspopup="menu" | |
| onClick={(e) => { | |
| e.preventDefault(); | |
| e.stopPropagation(); | |
| setMode("menu"); | |
| setName(entryLabel); | |
| openFrom(e.currentTarget); | |
| }} | |
| > | |
| <DotsIcon /> | |
| </button> | |
| {at && ( | |
| <MenuShell at={at} menuRef={ref} wide={mode === "delete"}> | |
| {mode === "delete" && canDelete ? ( | |
| <DeleteFace | |
| entryLabel={entryLabel} | |
| state={del} | |
| onCancel={() => setMode("menu")} | |
| onConfirm={runDelete} | |
| /> | |
| ) : mode === "rename" && renameOn ? ( | |
| <form | |
| className="shell-navmenu-form" | |
| onSubmit={(e) => { | |
| e.preventDefault(); | |
| submitRename(); | |
| }} | |
| > | |
| <input | |
| className="shell-navmenu-input" | |
| autoFocus | |
| maxLength={60} | |
| value={name} | |
| aria-label={`Rename ${entryLabel}`} | |
| onChange={(e) => setName(e.target.value)} | |
| onKeyDown={(e) => { | |
| if (e.key === "Escape") close(); | |
| }} | |
| /> | |
| <button type="submit" className="shell-navmenu-go" disabled={!name.trim()}> | |
| Save | |
| </button> | |
| </form> | |
| ) : mode === "icon" && iconOn ? ( | |
| /* ⚠ PICKING DOES NOT CLOSE THE MENU, and that is not a convenience. | |
| Shape and tone are two independent choices: a picker that closed | |
| on the first click would make "a green bolt" a two-open job, and | |
| the second open would have to find the row again. Each click | |
| commits (they are cheap and rare), the rail repaints from the | |
| server, and the swatch marks follow what was actually stored — so | |
| a refused write shows up as a mark that does not move, beside the | |
| toast that says why. Clearing DOES close: "use the default" is a | |
| terminal action, and the control removes itself once taken. */ | |
| <IconPicker | |
| value={icon} | |
| onPick={(next) => onIcon?.(next)} | |
| {...(icon && onIconClear | |
| ? { | |
| onClear: () => { | |
| close(); | |
| onIconClear(); | |
| }, | |
| } | |
| : {})} | |
| /> | |
| ) : ( | |
| <> | |
| {renameOn ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => setMode("rename")} | |
| > | |
| Rename | |
| </button> | |
| ) : null} | |
| {iconOn ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => setMode("icon")} | |
| > | |
| Change icon | |
| </button> | |
| ) : null} | |
| {canSchema ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => { | |
| close(); | |
| onSchema(); | |
| }} | |
| > | |
| View schema | |
| </button> | |
| ) : null} | |
| {/* WAVE 20 item 18 (R10, C-SHARE) — a DATABASE shares with the same two | |
| roles a view does. Gated on `onShare`, which the Shell passes only | |
| for a real database row, so a family head or a hand-off link never | |
| offers to share something that has no id on the server. */} | |
| {onShare ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => { | |
| close(); | |
| onShare(); | |
| }} | |
| > | |
| Share… | |
| </button> | |
| ) : null} | |
| {/* ⭐ WAVE 21 item 6 (R3) — LAST, and the only destructive row in this | |
| menu. Gated on the server's `canDelete` alone: R3 scopes the verb to | |
| the CREATOR or an admin and refuses it outright for connector-backed | |
| databases, so a row that may not be deleted does not say so — it | |
| simply has nothing here to click. (An entry that explains why it is | |
| disabled is the right pattern for a thing you could earn; this one | |
| you cannot.) */} | |
| {canDelete ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item is-danger" | |
| onClick={openDelete} | |
| > | |
| Delete database… | |
| </button> | |
| ) : null} | |
| </> | |
| )} | |
| </MenuShell> | |
| )} | |
| </> | |
| ); | |
| } | |
| /** One footprint line: "12 records", "1 view". Singular/plural is the whole of | |
| * the formatting, because a count with the wrong noun reads as a bug in the | |
| * count. */ | |
| function countLine(n: number, one: string, many: string): string { | |
| return `${n.toLocaleString()} ${n === 1 ? one : many}`; | |
| } | |
| /** | |
| * ⭐ WAVE 21 item 6 (R3, contract C3) — the confirm face: what deleting this | |
| * database destroys, stated before the button that does it. | |
| * | |
| * Shaped after `PermsEditor`'s confirm (`.set-confirm`, the strongest one this | |
| * codebase has) and not after a `window.confirm`: the browser dialog cannot say | |
| * anything specific, and a destructive question whose answer depends on facts | |
| * the asker has not been given is not really being asked. | |
| * | |
| * THREE STATES, worded differently on purpose: | |
| * · footprint undefined — still asking the server. The button is disabled; | |
| * confirming against numbers that have not arrived is confirming against | |
| * nothing. | |
| * · footprint null — the server would not say. The question is put | |
| * WITHOUT counts and says so. Inventing zeros here would be a specific, | |
| * checkable claim about the user's data that nobody verified | |
| * ([[no-unverifiable-aggregates]]). | |
| * · footprint present — every family it names, listed. | |
| * | |
| * ⚠ The automations line is the one that is NOT about destruction: C3 pauses | |
| * bound automations and stamps them "target deleted" rather than removing them, | |
| * so it names them (they will still be there afterwards, switched off) instead | |
| * of counting them away. | |
| */ | |
| function DeleteFace({ | |
| entryLabel, | |
| state, | |
| onCancel, | |
| onConfirm, | |
| }: { | |
| entryLabel: string; | |
| state: { footprint?: TableFootprint | null; busy: boolean; error: string }; | |
| onCancel: () => void; | |
| onConfirm: () => void; | |
| }) { | |
| const f = state.footprint; | |
| const asking = f === undefined; | |
| return ( | |
| <div className="shell-navconfirm" role="alertdialog" aria-modal="true" | |
| aria-label={`Delete ${entryLabel}`}> | |
| <h4 className="shell-navconfirm-h">Delete “{entryLabel}”?</h4> | |
| {asking ? ( | |
| <p className="shell-navmenu-note">Checking what this database holds…</p> | |
| ) : f === null ? ( | |
| <p className="shell-navmenu-note"> | |
| The server did not say what this database holds. Deleting it removes its records, | |
| columns, views, comments, documents and sharing — permanently. | |
| </p> | |
| ) : ( | |
| <> | |
| <p className="shell-navmenu-note">This cannot be undone. It permanently removes:</p> | |
| <ul className="shell-navconfirm-list"> | |
| <li>{countLine(f.rows, "record", "records")}</li> | |
| <li>{countLine(f.fields, "column", "columns")}</li> | |
| <li>{countLine(f.views, "view", "views")}</li> | |
| <li> | |
| {countLine(f.sharedUsers, "person it is shared with", | |
| "people it is shared with")} | |
| </li> | |
| </ul> | |
| {f.automations.length ? ( | |
| <p className="shell-navmenu-note"> | |
| {/* The VERB agrees too. "1 automation write here" was on screen before the | |
| first screenshot was read — the kind of thing every assertion passes. */} | |
| {countLine(f.automations.length, "automation", "automations")}{" "} | |
| {f.automations.length === 1 ? "writes" : "write"} here ( | |
| {f.automations.map((a) => a.name).join(", ")}) — {f.automations.length === 1 | |
| ? "it is" | |
| : "they are"}{" "} | |
| switched off, not deleted. | |
| </p> | |
| ) : null} | |
| </> | |
| )} | |
| {state.error ? <p className="shell-navconfirm-err">{state.error}</p> : null} | |
| <div className="shell-navconfirm-actions"> | |
| <button | |
| type="button" | |
| className="shell-navconfirm-go" | |
| disabled={asking || state.busy} | |
| onClick={onConfirm} | |
| > | |
| {state.busy ? "Deleting…" : "Delete"} | |
| </button> | |
| <button | |
| type="button" | |
| className="shell-navmenu-item is-quiet" | |
| disabled={state.busy} | |
| onClick={onCancel} | |
| > | |
| Keep it | |
| </button> | |
| </div> | |
| </div> | |
| ); | |
| } | |
| function PlusIcon() { | |
| return ( | |
| <svg viewBox="0 0 16 16" aria-hidden="true" className="shell-newthing-plus"> | |
| <path d="M8 3.4v9.2M3.4 8h9.2" /> | |
| </svg> | |
| ); | |
| } | |
| /** | |
| * Wave 14 C-NAVFOLD gave the list's bottom a quiet "+ New folder" (the Views-rail | |
| * precedent). WAVE 19 R11 made it "+ Create new…" with Folder | Database behind it. | |
| * | |
| * ⭐ WAVE 24 items 1 + 15a (ruling R9) — IT LEAVES THE RAIL AND BECOMES THE DATABASE | |
| * FLYOUT'S FOOTER, and it now carries the creatable things: New database · | |
| * From a template · New folder. The flyout's three standalone `.shell-dbfly-make` | |
| * buttons are deleted; this one control replaces them. | |
| * | |
| * ⭐ WAVE 25 item 5a (ruling R8) — "AUTOMATED DATABASE" IS DELETED FROM THIS MENU, | |
| * so it carries THREE rows rather than four. R8: creating a database is one act and | |
| * pointing an automation at it is another, so the automation door lives on the | |
| * automation surface (its rail button and its empty state) and this menu stops | |
| * offering a database that is really an automation. | |
| * ⚠ `From a template` and `New folder` are UNTOUCHED — neither was ever an automated | |
| * database, and R9 keeps the template door working here (see the Home card's own note | |
| * on why exactly one of the two template doors is boarded). | |
| * | |
| * ⭐ AND IT IS ALSO ITEM 1's FIX, which is worth stating because it does not look | |
| * like a typography change. MEASURED on staging v12: the six rail rows all render | |
| * 13.8125px / w500 / Inter / rgb(32,36,51) — identical, `<a>` and `<button>` alike. | |
| * The ONE row in that band that differed was this one: `.shell-newfolder` declares | |
| * `--lp-fs-2xs` (12.75px) with no `font-weight` (so 400, inherited) and | |
| * `--lp-muted`. Taking it out of the rail is what makes the band read as one set; | |
| * nothing about the other six needed changing, and changing them would have been a | |
| * fix aimed at the wrong row. | |
| * | |
| * ⚠ THE `canFolder` GATE SURVIVES THE MOVE, and it has to. Wave 19's note: folders | |
| * over an empty list are an empty gesture, but a freshly provisioned tenant must | |
| * still be able to create a DATABASE. So with no entries the menu simply omits its | |
| * folder row rather than the control collapsing to a single-purpose button — inside | |
| * a panel there is room for a menu whatever the tenant has, which is the one thing | |
| * the 236px rail could not say. | |
| */ | |
| export function CreateNewRow({ | |
| collapsed, | |
| onExpand, | |
| onCreateFolder, | |
| onNewDatabase, | |
| onFromTemplate, | |
| canFolder, | |
| }: { | |
| collapsed: boolean; | |
| /** Collapsed, the row's one honest behaviour is "open the rail first". */ | |
| onExpand: () => void; | |
| onCreateFolder: (name: string) => void; | |
| onNewDatabase: () => void; | |
| /** R9's second row — the template picker, over a database you already have. */ | |
| onFromTemplate: () => void; | |
| /* ⛔ `onAutomated` LEFT WITH THE ROW IT OPENED (wave 25 item 5a, R8). */ | |
| /** Folders over an empty list are an empty gesture — the row is omitted, not the menu. */ | |
| canFolder: boolean; | |
| }) { | |
| const { at, ref, openFrom, close } = useMenu(); | |
| const [naming, setNaming] = useState(false); | |
| const [name, setName] = useState(""); | |
| const submit = () => { | |
| const clean = name.trim().replace(/\s+/g, " "); | |
| if (!clean) return; | |
| onCreateFolder(clean); | |
| setName(""); | |
| setNaming(false); | |
| }; | |
| // ⛔ The 56px strip cannot hold a popover — the same reason the account row | |
| // expands instead of opening its menu. Preserved from the button this row | |
| // replaced, which did exactly this before opening its dialog. | |
| // | |
| // ⚠ WAVE 24: this branch is now UNREACHABLE FROM THE RAIL (the row is not there | |
| // any more) but it is NOT dead — the flyout can be opened with the rail folded, | |
| // and `collapsed` is still passed. Kept rather than deleted, because the panel's | |
| // own note says the folded rail is exactly the state a user who opened it is most | |
| // likely to be in. | |
| if (collapsed) { | |
| return ( | |
| <button | |
| type="button" | |
| className="shell-newfolder is-collapsed" | |
| aria-label="Create new" | |
| title="Create new" | |
| onClick={onExpand} | |
| > | |
| <PlusIcon /> | |
| </button> | |
| ); | |
| } | |
| if (!naming) { | |
| return ( | |
| <> | |
| {/* THE LABEL NO LONGER FOLLOWS `canFolder`. In the rail it had to: with one | |
| real branch, "+ Create new…" beside an `aria-haspopup` was a control | |
| promising a choice it was not about to offer. In the footer there are | |
| always at least two (database / template), so the menu is real whatever | |
| the tenant has and the label can simply be true. | |
| ⚠ TWO, NOT THREE, since R8 took the automated row (wave 25) — still a | |
| genuine choice, which is the property the label depends on. If a future | |
| ruling takes the template row as well, this reasoning inverts and the | |
| control has to become a plain button again. */} | |
| <button | |
| type="button" | |
| className="shell-newfolder" | |
| aria-haspopup="menu" | |
| onClick={(e) => openFrom(e.currentTarget)} | |
| > | |
| + Create new… | |
| </button> | |
| {at && ( | |
| <MenuShell at={at} menuRef={ref}> | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => { | |
| close(); | |
| onNewDatabase(); | |
| }} | |
| > | |
| New database | |
| </button> | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => { | |
| close(); | |
| onFromTemplate(); | |
| }} | |
| > | |
| From a template | |
| </button> | |
| {canFolder ? ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => { | |
| close(); | |
| setNaming(true); | |
| }} | |
| > | |
| New folder | |
| </button> | |
| ) : null} | |
| </MenuShell> | |
| )} | |
| </> | |
| ); | |
| } | |
| return ( | |
| <form | |
| className="shell-navmenu-form shell-newfolder-form" | |
| onSubmit={(e) => { | |
| e.preventDefault(); | |
| submit(); | |
| }} | |
| > | |
| <input | |
| className="shell-navmenu-input" | |
| autoFocus | |
| maxLength={40} | |
| placeholder="Folder name" | |
| value={name} | |
| onChange={(e) => setName(e.target.value)} | |
| onKeyDown={(e) => { | |
| if (e.key === "Escape") { | |
| setName(""); | |
| setNaming(false); | |
| } | |
| }} | |
| /> | |
| <button type="submit" className="shell-navmenu-go" disabled={!name.trim()}> | |
| Add | |
| </button> | |
| </form> | |
| ); | |
| } | |
| export function FolderHead({ | |
| folder, | |
| count, | |
| open, | |
| collapsed, | |
| onToggle, | |
| onRename, | |
| onDelete, | |
| isDrop, | |
| dropProps, | |
| }: { | |
| folder: NavFolder; | |
| count: number; | |
| open: boolean; | |
| collapsed: boolean; | |
| onToggle: () => void; | |
| onRename: (name: string) => void; | |
| onDelete: () => void; | |
| /** Wave 14 C-NAVFOLD — a database row is being dragged over this folder. */ | |
| isDrop?: boolean; | |
| /** dragover/drop handlers, owned by the Shell (it holds the placement writer). */ | |
| dropProps?: React.HTMLAttributes<HTMLDivElement>; | |
| }) { | |
| const { at, ref, openFrom, close } = useMenu(); | |
| const [renaming, setRenaming] = useState(false); | |
| const [name, setName] = useState(folder.name); | |
| const submit = () => { | |
| const clean = name.trim().replace(/\s+/g, " "); | |
| if (clean && clean !== folder.name) onRename(clean); | |
| setRenaming(false); | |
| close(); | |
| }; | |
| if (collapsed) { | |
| // The folded rail has no room for folder chrome; members render flat and the | |
| // folder simply waits for the rail to open again. | |
| return null; | |
| } | |
| return ( | |
| <div | |
| className={"shell-nav-folder" + (isDrop ? " is-drop" : "")} | |
| {...(dropProps ?? {})} | |
| > | |
| {/* R3: no chevron — the Views-rail folder look. Open state reads from the members | |
| below it (and aria-expanded says it aloud); the mark + bold label ARE the row. */} | |
| <button | |
| type="button" | |
| className="shell-nav-folderbtn" | |
| aria-expanded={open} | |
| onClick={onToggle} | |
| > | |
| <FolderIcon /> | |
| <span className="shell-nav-label">{folder.name}</span> | |
| <span className="shell-nav-foldercount">{count}</span> | |
| </button> | |
| <button | |
| type="button" | |
| className="shell-dots" | |
| aria-label={`Options for folder ${folder.name}`} | |
| aria-haspopup="menu" | |
| onClick={(e) => { | |
| e.stopPropagation(); | |
| setName(folder.name); | |
| setRenaming(false); | |
| openFrom(e.currentTarget); | |
| }} | |
| > | |
| <DotsIcon /> | |
| </button> | |
| {at && ( | |
| <MenuShell at={at} menuRef={ref}> | |
| {renaming ? ( | |
| <form | |
| className="shell-navmenu-form" | |
| onSubmit={(e) => { | |
| e.preventDefault(); | |
| submit(); | |
| }} | |
| > | |
| <input | |
| className="shell-navmenu-input" | |
| autoFocus | |
| maxLength={40} | |
| value={name} | |
| onChange={(e) => setName(e.target.value)} | |
| /> | |
| <button type="submit" className="shell-navmenu-go" disabled={!name.trim()}> | |
| Save | |
| </button> | |
| </form> | |
| ) : ( | |
| <button | |
| type="button" | |
| className="shell-navmenu-item" | |
| onClick={() => setRenaming(true)} | |
| > | |
| Rename folder | |
| </button> | |
| )} | |
| <button | |
| type="button" | |
| className="shell-navmenu-item is-danger" | |
| onClick={() => { | |
| close(); | |
| onDelete(); | |
| }} | |
| > | |
| Delete folder | |
| </button> | |
| </MenuShell> | |
| )} | |
| </div> | |
| ); | |
| } | |
| export function SchemaDrawer({ | |
| schemaKey, | |
| onClose, | |
| }: { | |
| schemaKey: string; | |
| onClose: () => void; | |
| }) { | |
| const [state, setState] = useState< | |
| { phase: "loading" } | { phase: "ready"; schema: SchemaPayload } | { phase: "error" } | |
| >({ phase: "loading" }); | |
| useEffect(() => { | |
| let cancelled = false; | |
| setState({ phase: "loading" }); | |
| fetchSchema(schemaKey).then((schema) => { | |
| if (cancelled) return; | |
| setState(schema ? { phase: "ready", schema } : { phase: "error" }); | |
| }); | |
| return () => { | |
| cancelled = true; | |
| }; | |
| }, [schemaKey]); | |
| useEffect(() => { | |
| const onKey = (e: KeyboardEvent) => { | |
| if (e.key === "Escape") onClose(); | |
| }; | |
| document.addEventListener("keydown", onKey, true); | |
| return () => document.removeEventListener("keydown", onKey, true); | |
| }, [onClose]); | |
| return ( | |
| <div className="shell-schema-backdrop" onMouseDown={onClose}> | |
| <aside | |
| className="shell-schema" | |
| role="dialog" | |
| aria-label="Database schema" | |
| onMouseDown={(e) => e.stopPropagation()} | |
| > | |
| {/* wave17 item 3 (R6) — the drawer opens on a mark, not on a sentence. */} | |
| {state.phase === "loading" && ( | |
| <div className="shell-schema-empty is-spin"> | |
| <span className="lp-spin lp-spin--lg" role="status" aria-label="Loading" /> | |
| </div> | |
| )} | |
| {state.phase === "error" && ( | |
| <div className="shell-schema-empty"> | |
| The schema could not be loaded. Close this panel and try again. | |
| </div> | |
| )} | |
| {state.phase === "ready" && ( | |
| <> | |
| <header className="shell-schema-head"> | |
| <div> | |
| <div className="shell-schema-title">{state.schema.label}</div> | |
| {state.schema.source && ( | |
| <div className="shell-schema-sub">Source · {state.schema.source}</div> | |
| )} | |
| </div> | |
| <button | |
| type="button" | |
| className="shell-schema-close" | |
| aria-label="Close schema" | |
| onClick={onClose} | |
| > | |
| × | |
| </button> | |
| </header> | |
| <div className="shell-schema-body"> | |
| {state.schema.note && ( | |
| <div className="shell-schema-note">{state.schema.note}</div> | |
| )} | |
| {state.schema.fields.length > 0 && ( | |
| <> | |
| <div className="shell-schema-kicker"> | |
| Fields · {state.schema.fields.length} | |
| </div> | |
| <table className="shell-schema-table"> | |
| <thead> | |
| <tr> | |
| <th>Field</th> | |
| <th>Type</th> | |
| <th>Source</th> | |
| </tr> | |
| </thead> | |
| <tbody> | |
| {state.schema.fields.map((f) => ( | |
| <tr key={f.key}> | |
| <td> | |
| <div className="shell-schema-fname">{f.label}</div> | |
| {f.description && ( | |
| <div className="shell-schema-fdesc">{f.description}</div> | |
| )} | |
| {f.options && ( | |
| <div className="shell-schema-fdesc"> | |
| Choices: {f.options.join(" · ")} | |
| </div> | |
| )} | |
| </td> | |
| <td className="shell-schema-type">{f.type}</td> | |
| <td className="shell-schema-type">{f.source}</td> | |
| </tr> | |
| ))} | |
| </tbody> | |
| </table> | |
| </> | |
| )} | |
| {state.schema.measures.length > 0 && ( | |
| <> | |
| <div className="shell-schema-kicker"> | |
| Semantic measures · {state.schema.measures.length} | |
| </div> | |
| <div className="shell-schema-measures"> | |
| {state.schema.measures.map((m) => ( | |
| <div key={m.key} className="shell-schema-measure"> | |
| <span className="shell-schema-fname">{m.label}</span> | |
| <span className="shell-schema-type">{m.type}</span> | |
| </div> | |
| ))} | |
| </div> | |
| </> | |
| )} | |
| </div> | |
| </> | |
| )} | |
| </aside> | |
| </div> | |
| ); | |
| } | |