Download web/src/assistant/OpenInPlace.tsx from fsanyoto/loopable: direct link, hf CLI and curl.
- Browser
- Download file 13.3 kB
-
https://huggingface.co/spaces/fsanyoto/loopable/resolve/9291c0100f4e7b8da2efcbbf1ebdea72ee1663e7/web/src/assistant/OpenInPlace.tsx
- Command line
-
hf download hf://spaces/fsanyoto/loopable@9291c0100f4e7b8da2efcbbf1ebdea72ee1663e7/web/src/assistant/OpenInPlace.tsx
-
curl -L -o OpenInPlace.tsx https://huggingface.co/spaces/fsanyoto/loopable/resolve/9291c0100f4e7b8da2efcbbf1ebdea72ee1663e7/web/src/assistant/OpenInPlace.tsx
13.3 kB
| // S72-T14 (R113, C3): a link in an answer opens one large centred pop-up that hosts the real | |
| // module. The pop-up never reads or writes `location.hash`, so the chat stays at `#/assistant`. | |
| // The host's mount point (AssistantPage.tsx) imports `styles/sdlc72/open-in-place.css`. | |
| import { | |
| Component, createContext, lazy, Suspense, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, | |
| } from "react"; | |
| import type { ComponentType, MouseEvent as ReactMouseEvent, ReactNode } from "react"; | |
| import { createPortal } from "react-dom"; | |
| import { NAV_MINIMIZE_EVENT } from "../apiContract"; | |
| import { OverlayProvider } from "../customer-grid/OverlaySurface"; | |
| import { ARTIFACTS_ROUTE, DATA_ROUTE, databaseEntries, QUERY_ROUTE, readDataAddress, routeKeyOf } from "../shell/nav"; | |
| import type { NavEntry } from "../shell/nav"; | |
| import { readSheetAddress } from "../sheet"; | |
| import { useEscapeClose } from "../ui/useEscapeClose"; | |
| import { ITEM_NOT_AVAILABLE } from "../ui/itemAvailability"; | |
| /** C3: the address a hosted module reads instead of the hash. */ | |
| export type EmbedAddress = { database?: string; view?: string; wb?: string; tab?: string }; | |
| type HostedNavigate = (address: { database: string; view?: string }) => void; | |
| /** C3: what `CustomerGrid` and `SheetPage` accept once lanes L and M land. */ | |
| export type EmbedModule = ComponentType<{ address?: EmbedAddress; embedded?: boolean; onNavigate?: HostedNavigate }>; | |
| export type QueryModule = ComponentType<{ granted: NavEntry[]; hostedRail?: boolean; selectedId?: string }>; | |
| /** S72-T16 (C7): one artifact record, shown by id. The host that mounts it injects it. */ | |
| export type ArtifactModule = ComponentType<{ id: string }>; | |
| /** One hostable address. A new kind adds a member here, a parser leg and a registry entry. */ | |
| export type InPlaceTarget = | |
| | { kind: "data"; database: string; view?: string } | |
| | { kind: "sheet"; wb: string; tab?: string } | |
| | { kind: "query"; id: string } | |
| | { kind: "artifact"; id: string }; | |
| /** The loader registry, injectable so a test mounts stubs. */ | |
| export interface InPlaceModules { | |
| data?: EmbedModule; | |
| sheet?: EmbedModule; | |
| query?: QueryModule; | |
| // No default: a host without it declines `#/artifacts?item=`, so the link navigates as before. | |
| artifact?: ArtifactModule; | |
| } | |
| export const NOT_AVAILABLE = ITEM_NOT_AVAILABLE; | |
| export const LOAD_FAILED = "This could not be opened. Close it and try again."; | |
| /** Map an in-app hash to a hostable target. Null keeps plain navigation. */ | |
| export function addressFromHash(hash: string): InPlaceTarget | null { | |
| const value = String(hash || "").trim(); | |
| if (!value.startsWith("#/")) return null; | |
| const route = routeKeyOf(value); | |
| if (route === DATA_ROUTE || route === "data") { | |
| const address = readDataAddress(value); | |
| return address.database ? { kind: "data", database: address.database, | |
| ...(address.view ? { view: address.view } : {}) } : null; | |
| } | |
| if (route === "sheet") { | |
| const address = readSheetAddress(value); | |
| return address?.wb ? { kind: "sheet", wb: address.wb, ...(address.tab ? { tab: address.tab } : {}) } : null; | |
| } | |
| if (route === QUERY_ROUTE || route === ARTIFACTS_ROUTE) { | |
| const params = new URLSearchParams(value.slice(2).split("#")[0].split("?")[1] ?? ""); | |
| const id = params.get("view"); | |
| if (id) return { kind: "query", id }; | |
| // C7: the in-app link of one artifact record. | |
| const item = route === ARTIFACTS_ROUTE ? params.get("item") : null; | |
| return item ? { kind: "artifact", id: item } : null; | |
| } | |
| return null; | |
| } | |
| export interface OpenInPlaceApi { | |
| /** Open the pop-up for an in-app hash. False when the hash is not hostable. */ | |
| open: (href: string) => boolean; | |
| } | |
| export const OpenInPlaceContext = createContext<OpenInPlaceApi | null>(null); | |
| /** The mounted host, or null. A null host keeps the link's plain hash navigation. */ | |
| export function useOpenInPlace(): OpenInPlaceApi | null { | |
| return useContext(OpenInPlaceContext); | |
| } | |
| type ClickLike = Pick<ReactMouseEvent, "button" | "metaKey" | "ctrlKey" | "shiftKey" | "altKey" | |
| | "defaultPrevented" | "preventDefault">; | |
| /** Handle a plain left click on an in-app link. True when the host opened it and the default stopped. */ | |
| export function interceptOpen(host: OpenInPlaceApi | null, href: string, event: ClickLike): boolean { | |
| if (!host || event.defaultPrevented || event.button !== 0) return false; | |
| if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return false; | |
| if (!addressFromHash(href)) return false; | |
| event.preventDefault(); | |
| return host.open(href); | |
| } | |
| // Only a `#/` target becomes a link. Any other scheme stays literal text. | |
| const ANSWER_LINK = /\[([^\]\n]+)\]\((#\/[^)\s]*)\)/g; | |
| /** Answer text with its `[label](#/...)` links as real links. */ | |
| export function LinkedText({ text }: { text: string }) { | |
| const host = useOpenInPlace(); | |
| const source = String(text ?? ""); | |
| const parts: ReactNode[] = []; | |
| let last = 0; | |
| for (const match of source.matchAll(ANSWER_LINK)) { | |
| const at = match.index ?? 0; | |
| if (at > last) parts.push(source.slice(last, at)); | |
| const href = match[2]; | |
| parts.push(<a key={`${at}-${href}`} className="as-inline-link" href={href} | |
| onClick={(event) => { interceptOpen(host, href, event); }}>{match[1]}</a>); | |
| last = at + match[0].length; | |
| } | |
| if (!parts.length) return <>{source}</>; | |
| if (last < source.length) parts.push(source.slice(last)); | |
| return <>{parts}</>; | |
| } | |
| type EmbedGrid = ComponentType<{ address?: EmbedAddress; embedded?: boolean }>; | |
| // tsc follows only literal specifiers. Vite expands each pattern (one file) at build. | |
| // ⛔ Not `import.meta.glob`: verify_alerts transpiles this file to CommonJS and allows only BASE_URL. | |
| const EXACT = ""; | |
| // The casts let this compile before and after lanes L and M add `address` to the modules. | |
| const DEFAULT_MODULES: Required<Omit<InPlaceModules, "artifact">> = { | |
| // The grid's menus need an overlay stack, as the shell's Data mount gives it. | |
| data: lazy(() => (import(`../customer-grid/CustomerGrid${EXACT}.tsx`) as Promise<{ default: unknown }>) | |
| .then((grid) => { | |
| const CustomerGrid = grid.default as EmbedGrid; | |
| return { default: (props: { address?: EmbedAddress; embedded?: boolean }) => | |
| <OverlayProvider><CustomerGrid {...props} /></OverlayProvider> }; | |
| })), | |
| sheet: lazy(() => (import(`../sheet/SheetPage${EXACT}.tsx`) as Promise<{ default: unknown }>) | |
| .then((page) => ({ default: page.default as EmbedModule }))), | |
| query: lazy(() => import(`../query/QueryPage${EXACT}.tsx`) as Promise<{ default: QueryModule }>), | |
| }; | |
| class InPlaceBoundary extends Component<{ children: ReactNode }, { failed: boolean }> { | |
| state = { failed: false }; | |
| static getDerivedStateFromError() { return { failed: true }; } | |
| render() { | |
| return this.state.failed ? <p className="oip-sentence" role="status">{LOAD_FAILED}</p> : this.props.children; | |
| } | |
| } | |
| function InPlaceLoading() { | |
| return <div className="oip-loading"><span className="lp-spin lp-spin--lg" role="status" aria-label="Loading" /></div>; | |
| } | |
| /** The pop-up's content: the hosted module, the loading state, or one plain sentence. */ | |
| export function InPlaceBody({ target, granted, modules, onNavigate }: { | |
| target: InPlaceTarget; granted: NavEntry[]; modules?: InPlaceModules; onNavigate?: HostedNavigate; | |
| }) { | |
| const registry = { ...DEFAULT_MODULES, ...modules }; | |
| let body: ReactNode; | |
| if (target.kind === "data") { | |
| const shared = databaseEntries(granted).some((entry) => entry.kind !== "group" && entry.key === target.database); | |
| if (!shared) return <p className="oip-sentence" role="status">{NOT_AVAILABLE}</p>; | |
| const CustomerGrid = registry.data; | |
| body = <CustomerGrid address={{ database: target.database, view: target.view }} embedded />; | |
| } else if (target.kind === "sheet") { | |
| const SheetPage = registry.sheet; | |
| body = <SheetPage address={{ wb: target.wb, tab: target.tab }} embedded onNavigate={onNavigate} />; | |
| } else if (target.kind === "artifact") { | |
| const ArtifactView = registry.artifact; | |
| if (!ArtifactView) return <p className="oip-sentence" role="status">{NOT_AVAILABLE}</p>; | |
| body = <ArtifactView id={target.id} />; | |
| } else { | |
| // QueryPage says its own plain sentence for an id that is gone or not shared. | |
| const QueryPage = registry.query; | |
| body = <QueryPage granted={granted} hostedRail selectedId={target.id} />; | |
| } | |
| return <InPlaceBoundary key={JSON.stringify(target)}><Suspense fallback={<InPlaceLoading />}>{body}</Suspense></InPlaceBoundary>; | |
| } | |
| const TITLES: Record<InPlaceTarget["kind"], string> = { data: "Records", sheet: "Sheet", query: "Artifact", artifact: "Artifact" }; | |
| const navFoldHolds = new Set<object>(); | |
| let restoreNavDispatch: (() => void) | null = null; | |
| /** Hold page-nav folding until the last hosted dialog unmounts. */ | |
| function holdPageNavFold(): () => void { | |
| const hold = {}; | |
| navFoldHolds.add(hold); | |
| if (navFoldHolds.size === 1) { | |
| const dispatch = window.dispatchEvent; | |
| // Direct window dispatch follows registration order, even for capture listeners. | |
| const intercept = function (this: Window, event: Event): boolean { | |
| if (event.type === NAV_MINIMIZE_EVENT && navFoldHolds.size) return !event.defaultPrevented; | |
| return dispatch.call(this, event); | |
| }; | |
| window.dispatchEvent = intercept; | |
| restoreNavDispatch = () => { | |
| if (window.dispatchEvent === intercept) window.dispatchEvent = dispatch; | |
| }; | |
| } | |
| return () => { | |
| if (!navFoldHolds.delete(hold) || navFoldHolds.size) return; | |
| restoreNavDispatch?.(); | |
| restoreNavDispatch = null; | |
| }; | |
| } | |
| /** The title names the database when the grant carries its label, in sentence case. */ | |
| export function inPlaceTitle(target: InPlaceTarget, granted: NavEntry[]): string { | |
| if (target.kind !== "data") return TITLES[target.kind]; | |
| const label = granted.find((entry) => entry.key === target.database)?.label; | |
| return label ? label.charAt(0).toUpperCase() + label.slice(1) : TITLES.data; | |
| } | |
| /** One large centred dialog over the chat. Esc, the close button or a click outside closes it. */ | |
| export function InPlaceDialog({ target, granted, modules, onClose, onNavigate }: { | |
| target: InPlaceTarget; granted: NavEntry[]; modules?: InPlaceModules; onClose: () => void; onNavigate?: HostedNavigate; | |
| }) { | |
| const panelRef = useRef<HTMLElement | null>(null); | |
| const pressedOutside = useRef(false); | |
| useEscapeClose(true, onClose, { container: () => panelRef.current }); | |
| useEffect(() => { panelRef.current?.focus({ preventScroll: true }); }, []); | |
| // Acquire before the hosted module's passive mount effects can dispatch a fold. | |
| useLayoutEffect(holdPageNavFold, []); | |
| const title = inPlaceTitle(target, granted); | |
| const dialog = <div className="oip-backdrop" | |
| onMouseDown={(event) => { pressedOutside.current = event.target === event.currentTarget; }} | |
| onClick={(event) => { | |
| if (pressedOutside.current && event.target === event.currentTarget) onClose(); | |
| pressedOutside.current = false; | |
| }}> | |
| <section className="oip-dialog" ref={panelRef} role="dialog" aria-modal="true" aria-label={title} tabIndex={-1}> | |
| <header className="oip-head"> | |
| <h2 className="oip-title">{title}</h2> | |
| <button type="button" className="oip-close" aria-label="Close" title="Close" onClick={onClose}> | |
| <svg viewBox="0 0 16 16" width="14" height="14" aria-hidden="true"><path d="M4 4l8 8M12 4l-8 8" /></svg> | |
| </button> | |
| </header> | |
| <div className="oip-body"><InPlaceBody target={target} granted={granted} modules={modules} onNavigate={onNavigate} /></div> | |
| </section> | |
| </div>; | |
| // Under SSR there is no body to portal into, so the dialog renders in place. | |
| return typeof document === "undefined" ? dialog : createPortal(dialog, document.body); | |
| } | |
| /** Provides `useOpenInPlace()` to the links below it and owns the one pop-up. */ | |
| export function OpenInPlaceHost({ granted, modules, children }: { | |
| granted: NavEntry[]; modules?: InPlaceModules; children?: ReactNode; | |
| }) { | |
| const [opened, setOpened] = useState<{ target: InPlaceTarget; serial: number } | null>(null); | |
| const opener = useRef<HTMLElement | null>(null); | |
| const serial = useRef(0); | |
| const open = useCallback((href: string) => { | |
| const target = addressFromHash(href); | |
| if (!target || (target.kind === "artifact" && !modules?.artifact)) return false; | |
| const active = typeof document === "undefined" ? null : document.activeElement; | |
| opener.current = active && "focus" in active ? active as HTMLElement : null; | |
| serial.current += 1; | |
| setOpened({ target, serial: serial.current }); | |
| return true; | |
| }, [modules?.artifact]); | |
| const close = useCallback(() => { | |
| setOpened(null); | |
| const back = opener.current; | |
| opener.current = null; | |
| back?.focus?.({ preventScroll: true }); | |
| }, []); | |
| const navigate = useCallback<HostedNavigate>((address) => { | |
| setOpened((current) => current ? { ...current, target: { kind: "data", ...address } } : current); | |
| }, []); | |
| const api = useMemo<OpenInPlaceApi>(() => ({ open }), [open]); | |
| return <OpenInPlaceContext.Provider value={api}> | |
| {children} | |
| {opened ? <InPlaceDialog key={opened.serial} target={opened.target} granted={granted} | |
| modules={modules} onClose={close} onNavigate={navigate} /> : null} | |
| </OpenInPlaceContext.Provider>; | |
| } | |