@riboseinc/paneron-registry-kit 2.0.0 → 2.0.1

package/compiled/views/change-request/Proposals.js

@@ -0,0 +1,185 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useEffect, useState } from 'react';
+import { jsx, css } from '@emotion/react';
+import styled from '@emotion/styled';
+import { ControlGroup, ButtonGroup, Switch, Button, Classes, MenuItem, NonIdealState, } from '@blueprintjs/core';
+import { Select2 as Select } from '@blueprintjs/select';
+import HelpTooltip from '@riboseinc/paneron-extension-kit/widgets/HelpTooltip';
+import { Protocols } from '../protocolRegistry';
+import { BrowserCtx } from '../BrowserCtx';
+import { itemPathToItemRef, itemRefToItemPath } from '../itemPathUtils';
+import StructuredDiff from '../diffing/StructuredDiff';
+import registerItemDetailView from '../detail/RegisterItem';
+const Proposals = function ({ proposals, className }) {
+    const [_selectedProposal, selectProposal] = useState(null);
+    const [showDiff, setShowDiff] = useState(false);
+    const [showOnlyChanged, setShowOnlyChanged] = useState(true);
+    const outerBrowserCtx = useContext(BrowserCtx);
+    const { jumpTo, subregisters, useRegisterItemData } = outerBrowserCtx;
+    const proposalBrowserCtx = {
+        ...outerBrowserCtx,
+        jumpTo: handleCRJump,
+    };
+    /**
+     * When jumping to an item affected by current CR,
+     * jump in-CR instead of spawning tab.
+     */
+    function handleCRJump(uri) {
+        if (uri.startsWith(Protocols.ITEM_DETAILS)) {
+            const itemPath = uri.split(':')[1];
+            if (proposals[itemPath]) {
+                selectProposal(itemPath);
+            }
+            else {
+                jumpTo?.(uri);
+            }
+        }
+    }
+    const firstProposal = Object.keys(proposals)[0];
+    // Effective selected proposal
+    const selectedProposal = ((_selectedProposal && proposals[_selectedProposal]) ? _selectedProposal : null)
+        ?? firstProposal
+        ?? undefined;
+    // Force select available proposal
+    useEffect(() => {
+        if (firstProposal && (_selectedProposal === null || !proposals[_selectedProposal])) {
+            selectProposal(firstProposal);
+        }
+    }, [firstProposal, _selectedProposal, JSON.stringify(proposals)]);
+    const selectedItemRef = selectedProposal
+        ? itemPathToItemRef(subregisters !== undefined, selectedProposal)
+        : null;
+    // Data for proposed items
+    const proposedItemPaths = Object.entries(proposals).map(([itemPath, proposal]) => {
+        if (proposal.type === 'clarification' || proposal.type === 'addition') {
+            return itemPath;
+        }
+        else {
+            return undefined;
+        }
+    }).filter(s => s !== undefined);
+    const proposedItemDataReq = useRegisterItemData({
+        itemPaths: proposedItemPaths,
+    });
+    // Data for pre-existing items
+    const currentItemDataReq = useRegisterItemData({
+        itemPaths: Object.keys(proposals),
+        ignoreActiveCR: true,
+    });
+    const getCurrentItemData = (itemPath) => currentItemDataReq.value[itemPath]?.data ?? null;
+    const getProposedItemData = (itemPath) => proposedItemDataReq.value[itemPath]?.data ?? null;
+    const selectedItemCurrentData = getCurrentItemData(selectedProposal);
+    const selectedItemProposedData = getProposedItemData(selectedProposal);
+    if (selectedProposal
+        && selectedItemRef
+        && proposals[selectedProposal]
+        && !currentItemDataReq.isUpdating
+        && !proposedItemDataReq.isUpdating) {
+        if (selectedItemCurrentData || selectedItemProposedData) {
+            const selectedItemSummary = jsx(ProposalSummary, { itemRef: selectedItemRef, itemData: (selectedItemProposedData ?? selectedItemCurrentData), itemDataBefore: selectedItemCurrentData ?? undefined, proposal: proposals[selectedProposal] });
+            return (jsx("div", { css: css `display: flex; flex-flow: column nowrap;`, className: className },
+                jsx("div", null,
+                    jsx(ControlGroup, null,
+                        jsx(Switch, { checked: showDiff, onChange: evt => setShowDiff(evt.currentTarget.checked), label: "View source", css: css `margin-right: 1em !important` }),
+                        jsx(Switch, { checked: showDiff && showOnlyChanged, disabled: !showDiff, onChange: evt => setShowOnlyChanged(evt.currentTarget.checked), label: "Show clarified properties only" })),
+                    jsx(ButtonGroup, null,
+                        jsx(Button, { disabled: !jumpTo || proposals[selectedProposal]?.type === 'addition', icon: 'locate', onClick: () => jumpTo?.(`${Protocols.ITEM_DETAILS}:${selectedProposal}`), title: "Open selected item in a new tab (not applicable to proposed additions)" }, "Reveal in registry"),
+                        Object.keys(proposals).length > 1
+                            ? jsx(Select, { filterable: false, itemsEqual: (i1, i2) => JSON.stringify(i1) === JSON.stringify(i2), activeItem: {
+                                    itemPath: selectedProposal,
+                                    proposal: proposals[selectedProposal],
+                                    itemData: (selectedItemProposedData ?? selectedItemCurrentData),
+                                    itemDataBefore: selectedItemCurrentData ?? undefined,
+                                    itemRef: itemPathToItemRef(subregisters !== undefined, selectedProposal),
+                                }, items: Object.entries(proposals).map(([itemPath, proposal]) => ({
+                                    itemPath,
+                                    proposal,
+                                    itemData: (getProposedItemData(itemPath) ?? getCurrentItemData(itemPath)) ?? null,
+                                    itemDataBefore: undefined,
+                                    itemRef: itemPathToItemRef(subregisters !== undefined, itemPath),
+                                })).filter(item => item.itemData !== null), popoverProps: { minimal: true }, fill: true, itemRenderer: ChangeProposalItemView, onItemSelect: (item) => selectProposal(item.itemPath) },
+                                jsx(Button, { rightIcon: "chevron-down", icon: getProposalIcon(proposals[selectedProposal]) }, selectedItemSummary))
+                            : jsx(Button, { fill: true, alignText: "left", icon: getProposalIcon(proposals[selectedProposal]), rightIcon: "chevron-down" }, selectedItemSummary))),
+                jsx("div", { css: css `position: relative; flex: 1;` },
+                    jsx(BrowserCtx.Provider, { value: proposalBrowserCtx },
+                        jsx(ProposalDetail, { itemRef: selectedItemRef, showDiff: showDiff, showOnlyChanged: showOnlyChanged, itemData: (selectedItemProposedData ?? selectedItemCurrentData), itemDataBefore: selectedItemCurrentData ?? undefined, proposal: proposals[selectedProposal] })))));
+        }
+        else {
+            return jsx(NonIdealState, { icon: 'warning-sign', className: className, title: "Unable to retrieve proposed item data", description: jsx("div", { css: css `text-align: left;` },
+                    "There appears to be a data integrity issue.",
+                    jsx("br", null),
+                    "This might be caused by a problem in the application, or repository contents having been edited outside of the application.",
+                    jsx("br", null),
+                    "The data should be recoverable by inspecting version control system commit history.") });
+        }
+    }
+    else {
+        return jsx(NonIdealState, { icon: 'clean', className: className, title: "Nothing is proposed here yet." });
+    }
+};
+const ChangeProposalItemView = (item, { handleClick, modifiers, query }) => {
+    const proposalConfig = item.proposal.type === 'amendment'
+        ? PROPOSAL_VIEWS[item.proposal.amendmentType]
+        : PROPOSAL_VIEWS[item.proposal.type];
+    const ProposalTypeLabel = proposalConfig.summary;
+    return (jsx(MenuItem, { active: modifiers.active, disabled: modifiers.disabled, labelElement: jsx(React.Fragment, null,
+            jsx(ProposalTypeLabel, { ...item }),
+            " ",
+            jsx(HelpTooltip, { content: jsx(React.Fragment, null,
+                    "Proposed to be ",
+                    proposalConfig.hint) })), key: item.itemPath, onClick: handleClick, icon: getProposalIcon(item.proposal), text: jsx(ProposalSummary, { ...item }) }));
+};
+export const ProposalDetail = function ({ proposal, showDiff, showOnlyChanged, itemRef, itemData, itemDataBefore, onChange }) {
+    const ItemView = registerItemDetailView.main;
+    const view = showDiff
+        ? jsx(MaximizedStructuredDiff, { item1: itemDataBefore ?? {}, item2: itemData, showUnchanged: !showOnlyChanged, css: css `background: white; border-radius: 2.5px; padding: 10px 0; margin: 10px 0;`, className: Classes.ELEVATION_2 })
+        : jsx(ItemView, { uri: itemRefToItemPath(itemRef), key: JSON.stringify(itemRef) });
+    return jsx("div", { css: css `position: absolute; inset: 0; display: flex; flex-flow: column;` }, view);
+};
+export const ProposalSummary = function ({ proposal, itemRef, itemData, itemDataBefore, onChange }) {
+    const { itemClasses } = useContext(BrowserCtx);
+    const { classID } = itemRef;
+    const ListItemView = itemClasses[classID].views.listItemView;
+    return jsx(ListItemView, { itemRef: itemRef, itemData: itemData });
+};
+const clarification = {
+    hint: jsx(React.Fragment, null, "altered to represent the same concept more clearly."),
+    summary: ({ proposal, itemData, itemRef }) => jsx(React.Fragment, null, "Clarification"),
+};
+const addition = {
+    hint: jsx(React.Fragment, null, "added to this register."),
+    summary: ({ proposal, itemData, itemRef }) => jsx(React.Fragment, null, "Addition"),
+};
+const retirement = {
+    hint: jsx(React.Fragment, null, "marked as no longer current. (Note that this register is append-only, so the item cannot be removed altogether.)"),
+    summary: ({ proposal, itemRef, itemData }) => jsx(React.Fragment, null, "Retirement"),
+};
+const supersession = {
+    hint: jsx(React.Fragment, null, "removed from the register with another item recommended for use in its place. A relation between the superseding and superseded item will be created, though the exact semantics of that relation depend on the register."),
+    summary: ({ proposal, itemRef, itemData }) => jsx(React.Fragment, null, "Supersession"),
+};
+const invalidation = {
+    hint: jsx(React.Fragment, null, "marked as invalid. The exact semantics of invalidation depend on the register."),
+    summary: ({ proposal, itemRef, itemData }) => jsx(React.Fragment, null, "Invalidation"),
+};
+const MaximizedStructuredDiff = styled(StructuredDiff) `
+  position: absolute;
+  inset: 0;
+`;
+const PROPOSAL_VIEWS = {
+    clarification,
+    addition,
+    retirement,
+    supersession,
+    invalidation,
+};
+function getProposalIcon(proposal) {
+    return proposal.type === 'addition'
+        ? 'add'
+        : proposal.type === 'clarification'
+            ? 'edit'
+            : 'ban-circle';
+}
+export default Proposals;
+//# sourceMappingURL=Proposals.js.map

package/compiled/views/change-request/objectChangeset.js

@@ -0,0 +1,189 @@
+import { isRegisterItem } from '../../types';
+import { State, } from '../../types/cr';
+import { crIDToCRPath, itemPathInCR, itemPathToItemRef, itemRefToItemPath } from '../itemPathUtils';
+/** Takes a justification and ID, returns an object changeset. */
+export function newCRObjectChangeset(id, justification, registerVersion, stakeholderGitServerUsername) {
+    const timeStarted = new Date();
+    const cr = {
+        id,
+        timeStarted,
+        timeEdited: timeStarted,
+        justification,
+        submittingStakeholderGitServerUsername: stakeholderGitServerUsername,
+        items: {},
+        state: State.DRAFT,
+        registerVersion: registerVersion.id,
+    };
+    const crObjectPath = crIDToCRPath(id);
+    return {
+        [crObjectPath]: {
+            oldValue: null,
+            newValue: cr,
+        },
+    };
+}
+/**
+ * Returns an object changeset to update CR with new given proposal items.
+ * Only applicable to CR at draft edit stage.
+ */
+export function updateCRObjectChangeset(
+/**
+ * Change request data.
+ */
+cr, 
+/**
+ * Proposals by item path.
+ * Will be merged with those already existing in `cr`.
+ * If a proposal is undefined, it will be removed.
+ */
+proposalItems, 
+/**
+ * New item data must be provided for additions and clarifications,
+ * keyed by item path.
+ */
+itemData = {}) {
+    const changeset = {};
+    const newItems = { ...cr.items };
+    for (const [itemPath, proposal] of Object.entries(proposalItems)) {
+        // Update proposals on CR
+        if (proposal !== null) {
+            newItems[itemPath] = proposal;
+        }
+        else if (newItems[itemPath]) {
+            delete newItems[itemPath];
+        }
+        // Add/remove item data
+        if (proposal?.type === 'addition' || proposal?.type === 'clarification') {
+            const proposedItemData = itemData[itemPath];
+            if (proposedItemData === null || !isRegisterItem(proposedItemData)) {
+                console.error("Unable to convert proposals to object changeset: original item data is missing", itemPath);
+                throw new Error("Unable to convert proposals to object changeset: original item data is missing");
+            }
+            changeset[itemPathInCR(itemPath, cr.id)] = {
+                // When editing a draft, we don’t care
+                // about overwriting proposed item data so we omit oldValue.
+                newValue: proposedItemData,
+            };
+        }
+        else {
+            changeset[itemPathInCR(itemPath, cr.id)] = {
+                // When editing a draft, we don’t care
+                // about overwriting proposed item data so we omit oldValue.
+                newValue: null,
+            };
+        }
+    }
+    // Update main CR data
+    const crPath = crIDToCRPath(cr.id);
+    changeset[crPath] = {
+        oldValue: cr,
+        newValue: { ...cr, items: newItems, timeEdited: new Date() },
+    };
+    return changeset;
+}
+/**
+ * Given change proposals, returns applicable changes
+ * to objects in the dataset.
+ */
+export async function proposalsToObjectChangeset(crID, hasSubregisters, proposals, itemData, newItemData) {
+    const cs = {};
+    for (const [itemPath, proposal] of Object.entries(proposals)) {
+        //const originalItem: RegisterItem<any> | undefined = (itemData[itemPath] ?? undefined);
+        const itemRef = itemPathToItemRef(hasSubregisters, itemPath);
+        if (proposal.type !== 'addition') {
+            if (itemData[itemPath] === undefined) {
+                console.error("Unable to convert proposals to object changeset: original item data is missing", itemPath);
+                throw new Error("Unable to convert proposals to object changeset: original item data is missing");
+            }
+            if (proposal.type === 'amendment' && proposal.amendmentType === 'supersession') {
+                Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+            }
+            else {
+                Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+            }
+        }
+        else {
+            Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+        }
+    }
+    return cs;
+}
+// TODO: Refactor out the business logic of proposal approval.
+/**
+ * Given a change proposal, returns applicable changes
+ * to objects in the dataset.
+ * Core logic of approving a proposal.
+ * Takes a proposal and extra options (depending on proposal type).
+ * Returns a Changeset containing register items at appropriate paths.
+ */
+async function proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData) {
+    let updatedItem;
+    const changeset = {};
+    const origItem = itemData[itemPath] ?? null;
+    const newItem = newItemData[itemPathInCR(itemPath, crID)] ?? null;
+    if (proposal.type !== 'addition') {
+        if (origItem === null) {
+            throw new Error("proposalToObjectChangeset() requires original item data for non-additions");
+        }
+        updatedItem = { ...origItem };
+        switch (proposal.type) {
+            case 'clarification':
+                if (newItem === null) {
+                    throw new Error("proposalToObjectChangeset() requires new item data for clarifications");
+                }
+                //const clarification = proposal as Clarification;
+                updatedItem.data = newItem.data; //clarification.payload;
+                break;
+            case 'amendment':
+                const amendment = proposal;
+                updatedItem.amendedInCR = crID;
+                switch (amendment.amendmentType) {
+                    case 'retirement':
+                        updatedItem.status = 'retired';
+                        break;
+                    case 'invalidation':
+                        updatedItem.status = 'invalid';
+                        break;
+                    case 'supersession':
+                        const supersession = proposal;
+                        updatedItem.status = 'superseded';
+                        updatedItem.supersededBy = supersession.supersedingItemIDs.map(itemID => ({
+                            itemID,
+                            classID: itemRef.classID,
+                            subregisterID: itemRef.subregisterID,
+                        }));
+                        for (const supersedingItemPath of updatedItem.supersededBy.map(ip => itemRefToItemPath(ip))) {
+                            const supersedingItemData = itemData[supersedingItemPath];
+                            if (supersedingItemData) {
+                                changeset[supersedingItemPath] = {
+                                    oldValue: supersedingItemData,
+                                    newValue: {
+                                        ...supersedingItemData,
+                                        supersedes: [...(supersedingItemData.supersedes ?? []), itemRef],
+                                    },
+                                };
+                            }
+                        }
+                        break;
+                }
+                break;
+        }
+    }
+    else {
+        if (newItem === null) {
+            throw new Error("proposalToObjectChangeset() requires new item data for additions");
+        }
+        updatedItem = {
+            id: itemRef.itemID,
+            data: newItem.data,
+            status: 'valid',
+            dateAccepted: new Date(),
+        };
+    }
+    changeset[itemPath] = {
+        oldValue: origItem,
+        newValue: updatedItem,
+    };
+    return changeset;
+}
+//# sourceMappingURL=objectChangeset.js.map

package/compiled/views/detail/ChangeRequest/Proposal.js

@@ -0,0 +1,144 @@
+"use strict";
+// /** @jsx jsx */
+// /** @jsxFrag React.Fragment */
+// 
+// 
+// import React from 'react';
+// 
+// import { jsx, css } from '@emotion/react';
+// 
+// import {
+//   FormGroup,
+//   InputGroup,
+//   NonIdealState,
+//   HTMLSelect,
+//   H4,
+// } from '@blueprintjs/core';
+// 
+// import useItemClassConfig from '../../hooks/useItemClassConfig';
+// 
+// import type {
+//   ChangeProposal,
+//   Payload,
+//   InternalItemReference,
+// } from '../../../types';
+// 
+// import { PROPOSAL_TYPES } from '../../../types';
+// 
+// 
+// const ProposalDetails: React.FC<{
+//   itemRef: InternalItemReference
+//   proposal: ChangeProposal
+// 
+//   existingItemData?: Payload
+// 
+//   onAccept?: (itemID: string, clsID: string) => void
+//   onChange?: (val: ChangeProposal) => void
+//   onDelete?: () => void
+// }> = function ({
+//   itemRef,
+//   proposal,
+//   onChange,
+//   existingItemData,
+// }) {
+//   const { value: classConfig } = useItemClassConfig(itemRef.classID ?? 'NONEXISTENT_CLASS_ID');
+//   const itemClass = classConfig;
+// 
+//   let itemView: JSX.Element;
+//   let proposalProperties: JSX.Element | null;
+// 
+//   if (proposal.type === 'amendment') {
+//     proposalProperties = (
+//       <FormGroup inline label="Supersede with:">
+//         <InputGroup
+//           value={proposal.amendmentType === 'supersession' ? proposal.supersedingItemID : ''}
+//           disabled={!onChange}
+//           placeholder="Item ID"
+//           onChange={onChange
+//             ? (evt: React.FormEvent<HTMLInputElement>) => {
+//                 if (!onChange) { return; }
+//                 const itemID = evt.currentTarget.value;
+//                 if (itemID.trim() === '') {
+//                   const newVal = update(proposal, { $unset: ['supersedingItemID'] });
+//                   onChange({ ...newVal, amendmentType: 'retirement' });
+//                 } else {
+//                   onChange({ ...proposal, amendmentType: 'supersession', supersedingItemID: itemID });
+//                 }
+//               }
+//             : undefined}/>
+//       </FormGroup>
+//     );
+//   } else {
+//     proposalProperties = null;
+//   }
+// 
+//   const itemData: Payload | undefined = proposal.type === 'addition'
+//     ? proposal.payload
+//     : existingItemData;
+// 
+//   if (itemData === undefined || !itemClass) {
+//     itemView = <NonIdealState icon="heart-broken" title="Unable to display this item" />;
+//   } else if (onChange && proposal.type !== 'amendment') {
+//     const EditView = itemClass.views.editView;// as ItemEditView<any>;
+//     itemView = <EditView
+//       itemRef={itemRef}
+//       itemData={itemData}
+//       onChange={onChange
+//         ? (payload) => onChange ? onChange({ ...proposal, payload }) : void 0
+//         : undefined} />;
+//   } else {
+//     const DetailView = itemClass.views.detailView ?? itemClass!.views.editView;// as ItemDetailView<any>;
+//     itemView = <DetailView
+//       itemRef={itemRef}
+//       itemData={itemData} />;
+//   }
+// 
+//   const canChangeProposalType = proposal.type !== 'addition';
+// 
+//   function handleTypeChange(type: string) {
+//     const pt = type as typeof PROPOSAL_TYPES[number];
+// 
+//     if (PROPOSAL_TYPES.indexOf(pt) < 0) { return; }
+//     if (!onChange || !canChangeProposalType || pt === 'addition' || existingItemData === undefined) { return; }
+// 
+//     if (pt === 'amendment') {
+//       onChange(update(proposal, {
+//         type: { $set: pt },
+//         amendmentType: { $set: 'retirement' },
+//         $unset: ['payload'],
+//       }));
+//     } else {
+//       onChange(update(proposal, {
+//         type: { $set: pt },
+//         payload: existingItemData,
+//       }));
+//     }
+//   }
+// 
+//   return (
+//     <div css={css`flex: 1; display: flex; flex-flow: column nowrap;`}>
+//       <div css={css`flex-shrink: 0; display: flex; flex-flow: row nowrap; align-items: center; margin-bottom: 1rem;`}>
+//         <HTMLSelect
+//           options={PROPOSAL_TYPES.map(pt => ({ value: pt, label: pt }))}
+//           //iconProps={{ icon: PROPOSAL_ICON[proposal.type] }}
+//           value={proposal.type}
+//           disabled={!onChange || !canChangeProposalType || existingItemData === undefined}
+//           onChange={(onChange && canChangeProposalType && existingItemData !== undefined)
+//             ? (evt) => handleTypeChange(evt.currentTarget.value)
+//             : undefined} />
+//         &ensp;
+//         of a
+//         &ensp;
+//         <H4 css={css`margin: 0;`}>{classConfig?.meta.title ?? 'unknown class'}</H4>
+//         {proposalProperties}
+//       </div>
+// 
+//       <div css={css`flex: 1; overflow-y: auto;`}>
+//         {itemView}
+//       </div>
+//     </div>
+//   );
+// };
+// 
+// export default ProposalDetails;
+//# sourceMappingURL=Proposal.js.map

package/compiled/views/detail/ChangeRequest/index.js

@@ -0,0 +1,140 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, Card, FormGroup, Colors, NonIdealState, Spinner, H5, UL, Tag, Divider, Classes, } from '@blueprintjs/core';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import HelpTooltip from '@riboseinc/paneron-extension-kit/widgets/HelpTooltip';
+import { BrowserCtx } from '../../BrowserCtx';
+import { crPathToCRID } from '../../itemPathUtils';
+import { ChangeRequestContextProvider, ChangeRequestContext, } from '../../change-request/ChangeRequestContext';
+import Proposals from '../../change-request/Proposals';
+import { hadBeenProposed, isDisposed } from '../../../types/cr';
+import { RegisterStakeholderListItem } from '../../RegisterStakeholder';
+import { TabContentsWithActions, RegisterHelmet as Helmet, maybeEllipsizeString, Datestamp, } from '../../util';
+import { TransitionOptions, getPastTransitions, getTransitions } from './transitions';
+const View = function ({ uri }) {
+    const crID = crPathToCRID(uri);
+    return (jsx(ChangeRequestContextProvider, { changeRequestID: crID },
+        jsx(ChangeRequestDetails, { css: css `
+        position: absolute;
+        inset: 0;
+        overflow-y: auto;
+      ` })));
+};
+const ChangeRequestDetails = function ({ className }) {
+    const { changeRequest: cr, canEdit } = useContext(ChangeRequestContext);
+    const { registerMetadata, stakeholder, activeChangeRequestID, setActiveChangeRequestID, } = useContext(BrowserCtx);
+    const helmet = jsx(Helmet, null,
+        jsx("title", null,
+            "Viewing proposal: ",
+            cr?.justification ?? "N/A"));
+    if (cr) {
+        const isActive = activeChangeRequestID === cr.id;
+        const anotherIsActive = activeChangeRequestID && activeChangeRequestID !== cr.id;
+        const canTransition = stakeholder && getTransitions(cr, stakeholder).length > 0;
+        const crStakeholder = (registerMetadata?.stakeholders ?? []).
+            find(s => s.gitServerUsername === cr.submittingStakeholderGitServerUsername);
+        return (jsx(TabContentsWithActions, { className: className, actions: jsx(React.Fragment, null,
+                jsx(FormGroup, { inline: true, labelInfo: jsx(HelpTooltip, { icon: 'info-sign', content: jsx(React.Fragment, null,
+                            jsx(UL, null,
+                                jsx("li", null,
+                                    "Proposal ID: ",
+                                    cr.id))) }), label: jsx("strong", null, "Proposal"), css: css `margin: 0; .bp4-form-content { display: flex; flex-flow: row wrap; gap: 10px; }` },
+                    jsx(CRActivation, { isActive: isActive, htmlTitle: anotherIsActive
+                            ? "You are in another proposal so you can’t enter this one. "
+                            : canEdit && !isActive
+                                ? "Enter proposal to preview or add to proposed changes. "
+                                : !isActive
+                                    ? "Enter proposal to preview the register as proposed."
+                                    : "You’re previewing the register with this proposal applied.", onChangeActiveStatus: !anotherIsActive && setActiveChangeRequestID
+                            ? ((active) => active
+                                ? setActiveChangeRequestID?.(cr.id)
+                                : setActiveChangeRequestID?.(null))
+                            : undefined }))), main: jsx("div", { css: css `
+                display: flex;
+                flex-flow: row wrap;
+                padding: 10px;
+                gap: 10px;
+                align-content: flex-start;
+                align-items: flex-start;
+              `, className: className },
+                helmet,
+                jsx(Card, { elevation: 0, css: css `
+              flex: 100%;
+              background: ${Colors.LIGHT_GRAY3};
+              padding: 11px;
+              display: flex;
+              min-height: 70vh;
+            ` },
+                    jsx(Proposals, { proposals: cr.items, css: css `flex: 1;` })),
+                jsx(Card, { elevation: 1, css: css `flex: 30%; padding: 11px;` },
+                    crStakeholder
+                        ? jsx("div", null,
+                            "Author: ",
+                            jsx(RegisterStakeholderListItem, { stakeholder: crStakeholder, isCurrentUser: cr.submittingStakeholderGitServerUsername === stakeholder?.gitServerUsername
+                                    ? true
+                                    : undefined }))
+                        : null,
+                    jsx(Divider, null),
+                    jsx("div", null,
+                        "To register version: ",
+                        jsx("strong", null, cr.registerVersion ?? 'N/A'),
+                        " ",
+                        cr.registerVersion === registerMetadata?.version?.id
+                            ? jsx(Tag, { css: css `display: inline;`, intent: 'success', minimal: true, round: true }, "current")
+                            : jsx(Tag, { css: css `display: inline;`, intent: 'warning', minimal: true, round: true },
+                                "not current",
+                                " ",
+                                jsx(HelpTooltip, { intent: 'warning', icon: 'warning-sign', content: jsx(React.Fragment, null,
+                                        "Register is currently at version ",
+                                        jsx("strong", null, registerMetadata?.version?.id ?? 'N/A'),
+                                        ",",
+                                        " ",
+                                        "which is different from version proposal author may have had in mind.",
+                                        " ",
+                                        "It is recommended that proposed changes are reviewed to avoid unintentionally",
+                                        " ",
+                                        "undoing a prior change.") }))),
+                    jsx(Divider, null),
+                    jsx("div", null,
+                        "Edited: ",
+                        jsx(Datestamp, { date: cr.timeEdited })),
+                    jsx(Divider, null),
+                    jsx("div", null,
+                        "Proposed: ",
+                        hadBeenProposed(cr) ? jsx(Datestamp, { date: cr.timeProposed }) : 'not yet'),
+                    jsx(Divider, null),
+                    jsx("div", null,
+                        "Disposed: ",
+                        isDisposed(cr) ? jsx(Datestamp, { date: cr.timeDisposed }) : 'not yet'),
+                    jsx(Divider, null),
+                    jsx(H5, null, cr.state?.replaceAll('-', ' ') || 'N/A')),
+                jsx(Card, { elevation: 1, css: css `flex: 30%; padding: 11px;` }, getPastTransitions(cr).map(([key, el], idx) => jsx(React.Fragment, { key: key },
+                    idx !== 0 ? jsx(Divider, null) : null,
+                    jsx(FormGroup, { label: `${key}:` },
+                        jsx("div", { css: css `white-space: pre-wrap;`, className: Classes.RUNNING_TEXT }, el))))),
+                canTransition
+                    ? jsx(Card, { elevation: 3, css: css `flex: 30%; padding: 11px;` },
+                        jsx(TransitionOptions, { cr: cr }))
+                    : null) }));
+    }
+    else {
+        return jsx(NonIdealState, { icon: jsx(Spinner, null), className: className, description: helmet });
+    }
+};
+const CRActivation = function ({ isActive, htmlTitle, labels, onChangeActiveStatus }) {
+    return onChangeActiveStatus && isActive
+        ? jsx(Button, { title: htmlTitle, intent: "warning", disabled: !onChangeActiveStatus, onClick: () => onChangeActiveStatus?.(false) }, labels?.deactivate ?? "Exit proposal")
+        : jsx(Button, { title: htmlTitle, intent: onChangeActiveStatus ? 'primary' : undefined, disabled: !onChangeActiveStatus, onClick: () => onChangeActiveStatus?.(true) }, labels?.activate ?? "Enter proposal");
+};
+const CRTitle = function ({ uri }) {
+    const { useObjectData } = useContext(DatasetContext);
+    const justification = useObjectData({ objectPaths: [uri] }).value.data?.[uri]?.justification;
+    return jsx(React.Fragment, null,
+        "Proposal \u201C",
+        maybeEllipsizeString(justification ?? uri),
+        "\u201D");
+};
+export default { main: View, title: CRTitle, plainTitle: async (uri) => `proposal ${uri}` };
+//# sourceMappingURL=index.js.map