@riboseinc/paneron-registry-kit 2.2.59 → 2.2.60

package/compiled/proposals/TransitionOptions.js

@@ -0,0 +1,432 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useState, useContext, useEffect, useMemo, useCallback } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, RadioGroup, Radio, FormGroup, TextArea, Colors } from '@blueprintjs/core';
+import { Tooltip2 as Tooltip } from '@blueprintjs/popover2';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { BrowserCtx } from '../views/BrowserCtx';
+import { isOwner, isControlBody, isManager } from '../types/stakeholder';
+import { itemPathInCR, crIDToCRPath } from '../views/itemPathUtils';
+import { proposalsToObjectChangeset } from './objectChangeset';
+import * as CR from './types';
+function reducer(prevState, action) {
+    switch (action.type) {
+        case 'unset-next-state':
+            return {
+                ...prevState,
+                chosenNextState: undefined,
+            };
+        case 'choose-next-state':
+            return {
+                ...prevState,
+                chosenNextState: action.payload.state,
+            };
+        case 'update-next-state-input':
+            return {
+                ...prevState,
+                stateInput: action.payload,
+            };
+        default:
+            throw new Error("Unexpected state");
+    }
+}
+//export const TransitionOptions: C extends CR.Base ? C["state"] extends keyof CR.Transitions ? React.FC<{ cr: CR.Base }> : never : never = function ({ cr }) {
+function TransitionOptions({ cr, transitions, stakeholder, className }) {
+    const { subregisters, alterApprovedCR } = useContext(BrowserCtx);
+    const { getObjectData, getMapReducedData, updateObjects, performOperation, operationKey, usePersistentDatasetStateReducer, } = useContext(DatasetContext);
+    const isBusy = operationKey !== undefined;
+    const initialState = useMemo((() => ({
+        // Pre-select next state to first available transition
+        chosenNextState: transitions.length > 0
+            ? transitions[0][0]
+            : undefined,
+        stateInput: {},
+    })), [transitions]);
+    // Set to a number of milliseconds to wait for, e.g. after selecting a new action,
+    // to avoid accidental transitions.
+    const [waitingForCooldown, setWaitingForCooldown] = useState(0);
+    const [state, dispatch, stateRecalled] = usePersistentDatasetStateReducer(`${cr.id}-${cr.state}`, undefined, undefined, reducer, initialState, null);
+    const selectedTransitionCfg = useMemo((() => {
+        var _a, _b;
+        return (_b = (stateRecalled && state.chosenNextState
+            ? (_a = transitions.find(([t,]) => t === state.chosenNextState)) === null || _a === void 0 ? void 0 : _a[1]
+            : undefined)) !== null && _b !== void 0 ? _b : undefined;
+    }), [stateRecalled, state.chosenNextState, transitions]);
+    useEffect((() => setWaitingForCooldown(2000)), [state.chosenNextState]);
+    useEffect(() => {
+        if (stateRecalled) {
+            // Don’t pre-select the next state checkbox.
+            // Persisting the state is still useful, since this remembers state input
+            // (such as register manager notes)
+            dispatch({ type: 'unset-next-state' });
+        }
+    }, [stateRecalled]);
+    //useEffect(() => {
+    //  if (stateRecalled && state.chosenNextState) {
+    //    if (!selectedTransitionCfg) {
+    //      dispatch({ type: 'unset-next-state' });
+    //    }
+    //  }
+    //}, [
+    //  stateRecalled,
+    //  state.chosenNextState,
+    //  selectedTransitionCfg,
+    //]);
+    const [validatedStateInput, stateInputValidationErrors] = useMemo(() => {
+        var _a;
+        if (cr && selectedTransitionCfg) {
+            try {
+                selectedTransitionCfg.func(cr, state.stateInput);
+            }
+            catch (e) {
+                return [undefined, (_a = e.message) !== null && _a !== void 0 ? _a : `${e}`];
+            }
+            return [state.stateInput, undefined];
+        }
+        else {
+            return [undefined, "no CR or no transition selected"];
+        }
+    }, [JSON.stringify(cr), selectedTransitionCfg, state.stateInput]);
+    const handleSetStateInput = useCallback((payload) => {
+        dispatch({
+            type: 'update-next-state-input',
+            payload,
+        });
+        setWaitingForCooldown(5000);
+    }, [dispatch, setWaitingForCooldown]);
+    useEffect(() => {
+        if (waitingForCooldown) {
+            const timeout = setTimeout((() => setWaitingForCooldown(v => v > 0 ? (v - 100) : v)), 100);
+            return function cleanUp() { clearTimeout(timeout); };
+        }
+        return function noop() { };
+    }, [waitingForCooldown, setWaitingForCooldown]);
+    const getItemChangesetAsApproved = useCallback(async function (cr) {
+        const origItemData = (await getObjectData({
+            objectPaths: [
+                ...Object.entries(cr.items).
+                    filter(([, prop]) => prop.type !== 'addition').
+                    map(([itemPath,]) => itemPath),
+                ...Object.values(cr.items).
+                    filter(prop => prop.type === 'amendment' && prop.amendmentType === 'supersession').
+                    flatMap(prop => prop.supersedingItemIDs),
+            ],
+        })).data;
+        //console.debug("Got orig item data", origItemData);
+        const newItemData = (await getObjectData({
+            objectPaths: Object.entries(cr.items).
+                filter(([, prop]) => prop.type === 'clarification' || prop.type === 'addition').
+                map(([itemPath,]) => itemPathInCR(itemPath, cr.id)),
+        })).data;
+        //console.debug("Got new item data", newItemData);
+        const maybeAlteredCR = alterApprovedCR
+            ? await alterApprovedCR(cr.id, cr.items, origItemData, newItemData, { getMapReducedData })
+            : { proposals: cr.items, origItemData, newItemData };
+        //console.debug("Got altered item data", newItemData);
+        return await proposalsToObjectChangeset(cr.id, subregisters !== undefined, maybeAlteredCR.proposals, maybeAlteredCR.origItemData, maybeAlteredCR.newItemData);
+    }, [cr.id, JSON.stringify(cr.items), subregisters === undefined, getObjectData, getMapReducedData, alterApprovedCR]);
+    const handleTransition = useCallback(async function (transitionCfg, stateInput) {
+        var _a;
+        if (transitionCfg && updateObjects && stakeholder && transitionCfg.canBeTransitionedBy(stakeholder, cr)) {
+            const newCR = {
+                ...transitionCfg.func(cr, stateInput),
+                state: transitionCfg.targetState,
+            };
+            newCR.pastTransitions = [
+                ...((_a = newCR.pastTransitions) !== null && _a !== void 0 ? _a : []),
+                {
+                    label: transitionCfg.title,
+                    timestamp: new Date(),
+                    fromState: cr.state,
+                    toState: newCR.state,
+                    stakeholder,
+                    input: stateInput,
+                },
+            ];
+            //console.debug("Transitioning CR", JSON.stringify(cr), JSON.stringify(newCR));
+            const changeset = {
+                [crIDToCRPath(cr.id)]: {
+                    oldValue: cr,
+                    newValue: newCR,
+                },
+            };
+            if (CR.isAccepted(newCR) || CR.isAcceptedOnAppeal(newCR)) {
+                Object.assign(changeset, await getItemChangesetAsApproved(newCR));
+            }
+            await updateObjects({
+                commitMessage: `${transitionCfg.title} CR`,
+                objectChangeset: changeset,
+            });
+        }
+        else {
+            throw new Error("Either transition is not specified or dataset is read-only");
+        }
+    }, [updateObjects, JSON.stringify(stakeholder), JSON.stringify(cr)]);
+    const canTransition = (selectedTransitionCfg !== undefined
+        && !isBusy
+        && validatedStateInput !== undefined
+        && !waitingForCooldown);
+    return (jsx("div", { css: css `display: flex; flex-flow: column nowrap;`, className: className },
+        transitions.length > 0
+            ? jsx(RadioGroup, { selectedValue: state.chosenNextState, onChange: (evt) => CR.isState(evt.currentTarget.value)
+                    ? dispatch({
+                        type: 'choose-next-state',
+                        payload: { state: evt.currentTarget.value },
+                    })
+                    : void 0 }, transitions.map(([state, cfg]) => jsx(Radio, { key: state, label: cfg.title, value: state, disabled: isBusy, large: true })))
+            : null,
+        (selectedTransitionCfg === null || selectedTransitionCfg === void 0 ? void 0 : selectedTransitionCfg.Widget)
+            ? jsx(Tooltip, { isOpen: stateInputValidationErrors !== undefined, placement: 'bottom', targetTagName: 'div', intent: 'warning', css: css `flex: 1;`, content: jsx(React.Fragment, null, stateInputValidationErrors) },
+                jsx(selectedTransitionCfg.Widget, { value: Object.keys(state.stateInput).length > 0
+                        ? state.stateInput
+                        : cr, onChange: !isBusy
+                        ? handleSetStateInput
+                        : undefined }))
+            : null,
+        selectedTransitionCfg
+            ? jsx(Button, { disabled: !canTransition, intent: canTransition ? 'primary' : undefined, onClick: () => validatedStateInput
+                    ? performOperation('transitioning CR state', handleTransition)(selectedTransitionCfg, validatedStateInput)
+                    : void 0 }, waitingForCooldown
+                ? jsx(React.Fragment, null,
+                    "Almost ready",
+                    Array(Math.floor(3 - (3 / 5000 * waitingForCooldown) + 1)).fill(undefined).map(() => jsx(React.Fragment, null, ".")))
+                : selectedTransitionCfg.title)
+            : null));
+}
+;
+/**
+ * Returns a list of transitions
+ * that can be performed on given CR by given stakeholder.
+ */
+export function getTransitions(cr, stakeholder) {
+    const possibleTransitions = TRANSITIONS[cr.state];
+    if (possibleTransitions) {
+        return (Object.entries(possibleTransitions).
+            filter(([, t]) => t.canBeTransitionedBy(stakeholder, cr)));
+    }
+    else {
+        return [];
+    }
+}
+/**
+ * Returns true if given CR can be transitioned
+ * *and* given stakeholder is eligible to transition it.
+ */
+export function canBeTransitionedBy(stakeholder, cr) {
+    return getTransitions(cr, stakeholder).length > 0;
+}
+/**
+ * Returns True if there is no possible transition for given state.
+ */
+export function isFinalState(state) {
+    var _a;
+    return (Object.keys((_a = TRANSITIONS[state]) !== null && _a !== void 0 ? _a : {})).length < 1;
+}
+const applyRegisterManagerDecision = function applyRegisterManagerDecision(cr, { registerManagerNotes }) {
+    return {
+        ...cr,
+        registerManagerNotes: registerManagerNotes !== null && registerManagerNotes !== void 0 ? registerManagerNotes : '',
+    };
+};
+const applyControlBodyDecision = function applyControlBodyDecision(cr, { controlBodyDecisionEvent }) {
+    //if (!controlBodyNotes?.trim()) {
+    //  throw new Error("Control body decision is required.");
+    //}
+    return {
+        ...cr,
+        //controlBodyNotes,
+        controlBodyDecisionEvent,
+    };
+};
+const applyAppeal = function applyAppeal(cr, { appealReason }) {
+    if (!(appealReason === null || appealReason === void 0 ? void 0 : appealReason.trim())) {
+        throw new Error("Appeal reason is required.");
+    }
+    return {
+        ...cr,
+        appealReason,
+        timeDisposed: undefined,
+    };
+};
+const applyRegisterOwnerDecision = function applyRegisterOwnerDecision(cr, { registerOwnerNotes }) {
+    if (!(registerOwnerNotes === null || registerOwnerNotes === void 0 ? void 0 : registerOwnerNotes.trim())) {
+        throw new Error("Register owner note is required.");
+    }
+    return {
+        ...cr,
+        registerOwnerNotes,
+        timeDisposed: new Date(),
+    };
+};
+const WITHDRAWAL_TRANSITION = {
+    title: "Withdraw",
+    targetState: CR.State.WITHDRAWN,
+    Widget: null,
+    canBeTransitionedBy: (stakeholder, cr) => cr.timeProposed && CR.isSubmittedBy(stakeholder, cr),
+    func: (cr) => ({
+        ...cr,
+        timeDisposed: new Date(),
+    }),
+};
+const SubmitterInputWidget = function ({ value, onChange }) {
+    return (jsx(FormGroup, { label: "Justification:" },
+        jsx(TransitionInputTextArea, { required: true, value: value.justification, onChange: (evt) => onChange === null || onChange === void 0 ? void 0 : onChange({ justification: evt.currentTarget.value }) })));
+};
+const TransitionInputTextArea = function (props) {
+    return jsx(TextArea, { fill: true, css: css `resize: vertical;`, readOnly: !props.onChange, ...props });
+};
+const PROPOSAL_TRANSITION = {
+    title: "Propose",
+    targetState: CR.State.PROPOSED,
+    canBeTransitionedBy: ((stakeholder, cr) => CR.isSubmittedBy(stakeholder, cr) && Object.keys(cr.items).length > 0),
+    Widget: SubmitterInputWidget,
+    func: (cr, submitterInput) => {
+        var _a;
+        if (!((_a = submitterInput === null || submitterInput === void 0 ? void 0 : submitterInput.justification) === null || _a === void 0 ? void 0 : _a.trim())) {
+            throw new Error("Justification is required.");
+        }
+        return {
+            ...cr,
+            ...submitterInput,
+            timeProposed: new Date(),
+        };
+    },
+};
+const RegisterManagerNotesWidget = function ({ value, onChange }) {
+    return (jsx(FormGroup, { label: "Register manager notes:" },
+        jsx(TransitionInputTextArea, { value: value.registerManagerNotes, required: true, onChange: evt => onChange === null || onChange === void 0 ? void 0 : onChange({ registerManagerNotes: evt.currentTarget.value }) })));
+};
+const ControlBodyDecisionWidget = function ({ value, onChange }) {
+    return (jsx(React.Fragment, null,
+        jsx(FormGroup, { label: "Control Body decision event:" },
+            jsx(TransitionInputTextArea, { value: value.controlBodyDecisionEvent, required: true, onChange: evt => onChange === null || onChange === void 0 ? void 0 : onChange({
+                    //controlBodyNotes: value.controlBodyNotes,
+                    controlBodyDecisionEvent: evt.currentTarget.value,
+                }) }))));
+};
+const AppealRequestWidget = function ({ value, onChange }) {
+    return (jsx(FormGroup, { label: "Appeal reasoning:" },
+        jsx(TransitionInputTextArea, { value: value.appealReason, required: true, onChange: evt => onChange === null || onChange === void 0 ? void 0 : onChange({ appealReason: evt.currentTarget.value }) })));
+};
+const RegisterOwnerNotesWidget = function ({ value, onChange }) {
+    return (jsx(FormGroup, { label: "Register owner notes:" },
+        jsx(TransitionInputTextArea, { value: value.registerOwnerNotes, required: true, onChange: evt => onChange === null || onChange === void 0 ? void 0 : onChange({ registerOwnerNotes: evt.currentTarget.value }) })));
+};
+export const STATE_INTENT = {
+    [CR.State.PROPOSED]: 'primary',
+    [CR.State.RETURNED_FOR_CLARIFICATION]: 'primary',
+    [CR.State.SUBMITTED_FOR_CONTROL_BODY_REVIEW]: 'primary',
+    [CR.State.APPEALED]: 'warning',
+};
+export const STATE_COLOR = {
+    [CR.State.PROPOSED]: Colors.BLUE2,
+    [CR.State.RETURNED_FOR_CLARIFICATION]: Colors.ORANGE3,
+    [CR.State.SUBMITTED_FOR_CONTROL_BODY_REVIEW]: Colors.BLUE2,
+    [CR.State.APPEALED]: Colors.ORANGE3,
+    [CR.State.REJECTED]: Colors.RED2,
+    [CR.State.REJECTION_UPHELD_ON_APPEAL]: Colors.RED2,
+    [CR.State.ACCEPTED]: Colors.GREEN2,
+    [CR.State.ACCEPTED_ON_APPEAL]: Colors.GREEN2,
+};
+/** Associates transition implementation with source/target states. */
+const TRANSITIONS = {
+    [CR.State.DRAFT]: {
+        [CR.State.WITHDRAWN]: WITHDRAWAL_TRANSITION,
+        [CR.State.PROPOSED]: PROPOSAL_TRANSITION,
+    },
+    [CR.State.PROPOSED]: {
+        [CR.State.WITHDRAWN]: WITHDRAWAL_TRANSITION,
+        [CR.State.SUBMITTED_FOR_CONTROL_BODY_REVIEW]: {
+            title: "Submit for control body review",
+            targetState: CR.State.SUBMITTED_FOR_CONTROL_BODY_REVIEW,
+            canBeTransitionedBy: (s) => isOwner(s) || isManager(s),
+            Widget: RegisterManagerNotesWidget,
+            func: applyRegisterManagerDecision,
+        },
+        [CR.State.RETURNED_FOR_CLARIFICATION]: {
+            title: "Return for clarification",
+            targetState: CR.State.RETURNED_FOR_CLARIFICATION,
+            canBeTransitionedBy: (s) => isOwner(s) || isManager(s),
+            Widget: RegisterManagerNotesWidget,
+            func: function applyRegisterManagerReturnDecision(cr, payload) {
+                var _a;
+                if (((_a = payload.registerManagerNotes) !== null && _a !== void 0 ? _a : '').trim() === '') {
+                    throw new Error("Register manager notes are required if returning for clarification");
+                }
+                return applyRegisterManagerDecision(cr, payload);
+            },
+        },
+    },
+    [CR.State.SUBMITTED_FOR_CONTROL_BODY_REVIEW]: {
+        [CR.State.WITHDRAWN]: WITHDRAWAL_TRANSITION,
+        [CR.State.RETURNED_FOR_CLARIFICATION]: {
+            title: "Return for clarification",
+            targetState: CR.State.RETURNED_FOR_CLARIFICATION,
+            canBeTransitionedBy: (s) => isOwner(s) || isControlBody(s),
+            Widget: ControlBodyDecisionWidget,
+            func: applyControlBodyDecision,
+        },
+        [CR.State.ACCEPTED]: {
+            title: "Accept",
+            targetState: CR.State.ACCEPTED,
+            canBeTransitionedBy: (s) => isOwner(s) || isControlBody(s),
+            Widget: ControlBodyDecisionWidget,
+            func: (cr, controlBodyInput) => ({
+                ...applyControlBodyDecision(cr, controlBodyInput),
+                timeDisposed: new Date(),
+            }),
+        },
+        [CR.State.REJECTED]: {
+            title: "Reject",
+            targetState: CR.State.REJECTED,
+            canBeTransitionedBy: (s) => isOwner(s) || isControlBody(s),
+            Widget: ControlBodyDecisionWidget,
+            func: (cr, controlBodyInput) => ({
+                ...applyControlBodyDecision(cr, controlBodyInput),
+                timeDisposed: new Date(),
+            }),
+        },
+    },
+    [CR.State.RETURNED_FOR_CLARIFICATION]: {
+        [CR.State.PROPOSED]: PROPOSAL_TRANSITION,
+        [CR.State.WITHDRAWN]: WITHDRAWAL_TRANSITION,
+    },
+    [CR.State.REJECTED]: {
+        [CR.State.APPEALED]: {
+            title: "Appeal",
+            targetState: CR.State.APPEALED,
+            canBeTransitionedBy: CR.isSubmittedBy,
+            Widget: AppealRequestWidget,
+            func: applyAppeal,
+        },
+    },
+    [CR.State.APPEALED]: {
+        [CR.State.APPEAL_WITHDRAWN]: {
+            title: "Withdraw appeal",
+            targetState: CR.State.APPEAL_WITHDRAWN,
+            canBeTransitionedBy: CR.isSubmittedBy,
+            Widget: null,
+            func: (cr) => ({
+                ...cr,
+                timeDisposed: new Date(),
+            }),
+        },
+        [CR.State.ACCEPTED_ON_APPEAL]: {
+            title: "Accept on appeal",
+            targetState: CR.State.ACCEPTED_ON_APPEAL,
+            canBeTransitionedBy: isOwner,
+            Widget: RegisterOwnerNotesWidget,
+            func: applyRegisterOwnerDecision,
+        },
+        [CR.State.REJECTION_UPHELD_ON_APPEAL]: {
+            title: "Uphold rejection",
+            targetState: CR.State.REJECTION_UPHELD_ON_APPEAL,
+            canBeTransitionedBy: isOwner,
+            Widget: RegisterOwnerNotesWidget,
+            func: applyRegisterOwnerDecision,
+        },
+    },
+};
+export default TransitionOptions;
+//# sourceMappingURL=TransitionOptions.js.map

package/compiled/proposals/actionableGroups/Tree.js

@@ -0,0 +1,170 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { useContext, useCallback, useMemo } from 'react';
+import update from 'immutability-helper';
+import { jsx, css } from '@emotion/react';
+import { Colors, Tree } from '@blueprintjs/core';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import { ChangeRequestContext } from '../ChangeRequestContext';
+import { BrowserCtx } from '../../views/BrowserCtx';
+import { getActionableProposalGroupsForRoles } from './queries';
+import { Protocols } from '../../views/protocolRegistry';
+import { getMapReduceChainsForActionableProposalGroups, getActionableProposalGroupsAsTreeNodes, } from './treeNodes';
+const initialState = {
+    //selectedFolderID: null,
+    selectedItemID: null,
+    expandedFolderIDs: [],
+};
+const ActionableCRTree = function ({ className }) {
+    var _a;
+    const { changeRequest: activeCR } = useContext(ChangeRequestContext);
+    const { setActiveChangeRequestID, stakeholder } = useContext(BrowserCtx);
+    const { usePersistentDatasetStateReducer, useMapReducedData } = useContext(DatasetContext);
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const [state, dispatch,] = usePersistentDatasetStateReducer('actionable-proposals', undefined, undefined, (prevState, action) => {
+        switch (action.type) {
+            case 'select-folder':
+                if (prevState.selectedItemID !== action.payload.folderID) {
+                    return {
+                        ...prevState,
+                        selectedItemID: action.payload.folderID,
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            case 'enter-folder':
+                if (!prevState.expandedFolderIDs.includes(action.payload.folderID)) {
+                    return {
+                        ...prevState,
+                        selectedItemID: action.payload.folderID,
+                        expandedFolderIDs: update(prevState.expandedFolderIDs, { $push: [action.payload.folderID] }),
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            case 'exit-folder':
+                const idx = prevState.expandedFolderIDs.indexOf(action.payload.folderID);
+                if (idx >= 0) {
+                    return {
+                        ...prevState,
+                        selectedItemID: action.payload.folderID,
+                        expandedFolderIDs: update(prevState.expandedFolderIDs, { $splice: [[idx, 1]] }),
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            case 'select-item':
+                if (prevState.selectedItemID !== action.payload.itemID) {
+                    return {
+                        ...prevState,
+                        selectedItemID: action.payload.itemID,
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            default:
+                throw new Error("Unexpected browse state");
+        }
+    }, initialState, null);
+    const groups = getActionableProposalGroupsForRoles((_a = stakeholder === null || stakeholder === void 0 ? void 0 : stakeholder.roles) !== null && _a !== void 0 ? _a : []);
+    const chains = stakeholder
+        ? getMapReduceChainsForActionableProposalGroups(groups, stakeholder)
+        : {};
+    const actionableProposalsResult = useMapReducedData({ chains });
+    const actionableProposals = useMemo((() => Object.entries(actionableProposalsResult.value).
+        map(([chainID, chainResult]) => ({
+        groupLabel: chainID,
+        proposals: (Array.isArray(chainResult)
+            // TODO: Validate results
+            ? chainResult
+            : undefined) || undefined
+    }))), [actionableProposalsResult.value]);
+    const nodes = useMemo((() => getActionableProposalGroupsAsTreeNodes(actionableProposals, {
+        activeCRID: activeCR === null || activeCR === void 0 ? void 0 : activeCR.id,
+        expandedGroupLabels: new Set(state.expandedFolderIDs),
+        onActivateCR: setActiveChangeRequestID,
+        selectedGroup: state.selectedItemID
+            ? actionableProposals.
+                find(({ groupLabel }) => groupLabel === state.selectedItemID)
+                ? state.selectedItemID
+                : undefined
+            : undefined,
+        selectedCRID: state.selectedItemID
+            ? actionableProposals.
+                flatMap(({ proposals }) => proposals !== null && proposals !== void 0 ? proposals : []).
+                find(p => p.id === state.selectedItemID)
+                ? state.selectedItemID
+                : undefined
+            : undefined,
+    })), [activeCR === null || activeCR === void 0 ? void 0 : activeCR.id, setActiveChangeRequestID, actionableProposals, state.selectedItemID, state.expandedFolderIDs.join(',')]);
+    const activate = useCallback(((proposalID) => {
+        if (proposalID !== (activeCR === null || activeCR === void 0 ? void 0 : activeCR.id)) {
+            setActiveChangeRequestID === null || setActiveChangeRequestID === void 0 ? void 0 : setActiveChangeRequestID(proposalID);
+        }
+        // open proposal dashboard regardless
+        spawnTab(Protocols.PROPOSAL_WORK, { atIdx: 0 });
+    }), [activeCR === null || activeCR === void 0 ? void 0 : activeCR.id, setActiveChangeRequestID, spawnTab]);
+    const eventHandlers = useMemo((() => ({
+        onNodeClick: (node) => {
+            var _a;
+            return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.type) === 'group'
+                ? dispatch({
+                    type: 'select-folder',
+                    payload: { folderID: node.id },
+                })
+                : dispatch({
+                    type: 'select-item',
+                    payload: { itemID: node.id },
+                });
+        },
+        onNodeExpand: (node) => {
+            var _a;
+            return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.type) === 'group'
+                ? dispatch({
+                    type: 'enter-folder',
+                    payload: { folderID: node.id },
+                })
+                : void 0;
+        },
+        onNodeCollapse: (node) => {
+            var _a;
+            return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.type) === 'group'
+                ? dispatch({
+                    type: 'exit-folder',
+                    payload: { folderID: node.id },
+                })
+                : void 0;
+        },
+        onNodeDoubleClick: (node) => {
+            var _a;
+            return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.type) === 'group'
+                ? dispatch({
+                    type: 'enter-folder',
+                    payload: { folderID: node.id },
+                })
+                : activate(node.id);
+        },
+    })), [dispatch, activate]);
+    return jsx(Tree, { className: className, contents: nodes, css: css `
+      .bp4-tree-node {
+        &.tree-node-active-proposal, &.tree-node-proposal-group-with-active-proposal:not(.bp4-tree-node-expanded) {
+          > .bp4-tree-node-content {
+            background: ${Colors.RED5};
+            .bp4-dark & {
+              background: ${Colors.RED2};
+            }
+          }
+          &.bp4-tree-node-selected > .bp4-tree-node-content {
+            background: ${Colors.RED3};
+          }
+        }
+      }
+    `, ...eventHandlers });
+};
+export default ActionableCRTree;
+//# sourceMappingURL=Tree.js.map

package/compiled/proposals/actionableGroups/queries.js

@@ -0,0 +1,78 @@
+import { State } from '../types';
+export function getActionableProposalGroupsForRole(role) {
+    return CR_QUERIES_FOR_ROLES.filter(([, roles]) => roles.has(role));
+}
+export function getActionableProposalGroupsForRoles(roles) {
+    return roles.flatMap(getActionableProposalGroupsForRole);
+}
+const CR_QUERIES_FOR_ROLES = [
+    ['My Drafts', new Set(['submitter', 'manager', 'control-body', 'owner']), function submitterProposals(stakeholder) {
+            if (stakeholder && stakeholder.gitServerUsername) {
+                const stakeholderCondition = `obj.submittingStakeholderGitServerUsername === "${stakeholder.gitServerUsername}"`;
+                const query = `(obj.state === "${State.DRAFT}" || obj.state === "${State.RETURNED_FOR_CLARIFICATION}") && (${stakeholderCondition})`;
+                return query;
+            }
+            else {
+                return 'false';
+            }
+        }],
+    ['My Rejected', new Set(['submitter', 'manager', 'control-body', 'owner']), function submitterProposals(stakeholder) {
+            // Rejections are actionable because they can be appealed by the submitter.
+            if (stakeholder && stakeholder.gitServerUsername) {
+                const stakeholderCondition = `obj.submittingStakeholderGitServerUsername === "${stakeholder.gitServerUsername}"`;
+                const query = `(obj.state === "${State.REJECTED}") && (${stakeholderCondition})`;
+                return query;
+            }
+            else {
+                return 'false';
+            }
+        }],
+    ['Everyone’s Drafts or Returned', new Set(['manager', 'control-body', 'owner']), function submitterProposals(stakeholder) {
+            if (stakeholder && stakeholder.gitServerUsername) {
+                const stakeholderCondition = `obj.submittingStakeholderGitServerUsername !== "${stakeholder.gitServerUsername}"`;
+                const query = `(obj.state === "${State.DRAFT}" || obj.state === "${State.RETURNED_FOR_CLARIFICATION}") && (${stakeholderCondition})`;
+                return query;
+            }
+            else {
+                return 'false';
+            }
+        }],
+    // ['latest reviewed', new Set(['submitter', 'manager', 'control-body', 'owner']), function submitterProposals(stakeholder) {
+    //   // TODO: Should filter only rejected perhaps?
+    //   // Approved/accepted proposals can be shown in another (public) area.
+    //   if (stakeholder && stakeholder.gitServerUsername) {
+    //     const stakeholderCondition = stakeholder?.role !== 'submitter'
+    //       ? 'true'
+    //       : `obj.submittingStakeholderGitServerUsername === "${stakeholder.gitServerUsername}"`;
+    //     // Don’t show drafts in the list of pending proposals, unless it’s user’s own drafts.
+    //     const query = `(obj.state === "${State.ACCEPTED} || obj.state === "${State.REJECTED} || obj.state === "${State.REJECTION_UPHELD_ON_APPEAL}"") && ${stakeholderCondition}`;
+    //     return query;
+    //   } else {
+    //     return 'false';
+    //   }
+    //   // TODO: Implement limit
+    // }],
+    // ['latest withdrawn', new Set(['submitter', 'manager', 'control-body', 'owner']), function submitterProposals(stakeholder) {
+    //   if (stakeholder && stakeholder.gitServerUsername) {
+    //     const stakeholderCondition = stakeholder?.role !== 'submitter'
+    //       ? 'true'
+    //       : `obj.submittingStakeholderGitServerUsername === "${stakeholder.gitServerUsername}"`;
+    //     // Don’t show drafts in the list of pending proposals, unless it’s user’s own drafts.
+    //     const query = `(obj.state === "${State.WITHDRAWN}" || obj.state === "${State.APPEAL_WITHDRAWN}") && ${stakeholderCondition}`;
+    //     return query;
+    //   } else {
+    //     return 'false';
+    //   }
+    //   // TODO: Implement limit
+    // }],
+    ['Pending Owner Appeal Review', new Set(['owner']), function ownerProposals() {
+            return `obj.state === "${State.APPEALED}"`;
+        }],
+    ['Pending Control Body Review', new Set(['control-body', 'owner']), function cbProposals() {
+            return `obj.state === "${State.SUBMITTED_FOR_CONTROL_BODY_REVIEW}"`;
+        }],
+    ['Pending Manager Review', new Set(['manager', 'control-body', 'owner']), function managerProposals() {
+            return `obj.state === "${State.PROPOSED}"`;
+        }],
+];
+//# sourceMappingURL=queries.js.map