@riboseinc/paneron-registry-kit 2.2.58 → 2.2.60

package/compiled/proposals/ProposalBrowser.js

@@ -0,0 +1,141 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useCallback, useMemo } from 'react';
+import { ClassNames, jsx, css } from '@emotion/react';
+import { Select2 as Select } from '@blueprintjs/select';
+import { ButtonGroup, Button, Drawer, DrawerSize } from '@blueprintjs/core';
+import ErrorBoundary from '@riboseinc/paneron-extension-kit/widgets/ErrorBoundary';
+import { useItemRef, itemPathToItemRef } from '../views/itemPathUtils';
+import { BrowserCtx } from '../views/BrowserCtx';
+import { Protocols } from '../views/protocolRegistry';
+import { ChangeProposalItemView, getProposalIcon } from './ProposalItem';
+import ProposalSummary from './ProposalSummary';
+import ProposalDetail from './ProposalDetail';
+/**
+ * Shows a list of individual proposed changes as cards by default,
+ * allowing to expand a proposal and view item details.
+ *
+ * If no proposals exist, returns null.
+ */
+export function ProposalBrowser({ proposals, hadBeenAccepted, onDeleteProposalForItemAtPath, selectedItem, onSelectItem: selectProposal }) {
+    const selectedProposal = selectedItem !== null && selectedItem !== void 0 ? selectedItem : null;
+    // TODO: Temporarily unsupported
+    // (limitations of current change annotation implementation)
+    //const [ showOnlyChanged, setShowOnlyChanged ] = useState(true);
+    const outerBrowserCtx = useContext(BrowserCtx);
+    const { jumpTo, subregisters, useRegisterItemData } = outerBrowserCtx;
+    /**
+     * When jumping to an item affected by current CR,
+     * jump in-CR instead of spawning tab.
+     */
+    const handleCRJump = useCallback(function _handleCRJump(uri) {
+        if (uri.startsWith(Protocols.ITEM_DETAILS)) {
+            const itemPath = uri.split(':')[1];
+            if (proposals[itemPath]) {
+                selectProposal(itemPath);
+            }
+            else {
+                jumpTo === null || jumpTo === void 0 ? void 0 : jumpTo(uri);
+            }
+        }
+    }, [Object.keys(proposals), jumpTo]);
+    const proposalBrowserCtx = useMemo((() => ({
+        ...outerBrowserCtx,
+        jumpTo: handleCRJump,
+    })), [handleCRJump, outerBrowserCtx]);
+    /** Paths of register items in proposal. */
+    const proposedItemPaths = Object.entries(proposals).map(([itemPath, proposal]) => {
+        if (proposal.type === 'clarification' || proposal.type === 'addition') {
+            return itemPath;
+        }
+        else {
+            return undefined;
+        }
+    }).filter(s => s !== undefined);
+    /** Proposed data of register items in proposal. */
+    const proposedItemDataReq = useRegisterItemData({
+        itemPaths: proposedItemPaths,
+    });
+    /** Pre-existing data of register items in proposal. */
+    const currentItemDataReq = useRegisterItemData({
+        itemPaths: Object.keys(proposals),
+        ignoreActiveCR: true,
+    });
+    const getCurrentItem = useCallback(((itemPath) => { var _a; return (_a = currentItemDataReq.value[itemPath]) !== null && _a !== void 0 ? _a : null; }), [currentItemDataReq.value]);
+    const getProposedItem = useCallback(((itemPath) => { var _a; return (_a = proposedItemDataReq.value[itemPath]) !== null && _a !== void 0 ? _a : null; }), [proposedItemDataReq.value]);
+    /** Current register item (if any) corresponding to selected proposal. */
+    const selectedItemCurrent = selectedProposal ? getCurrentItem(selectedProposal) : null;
+    /** Proposed register item corresponding to selected proposal. */
+    const selectedItemProposed = selectedProposal ? getProposedItem(selectedProposal) : null;
+    const selectedItemRef = useItemRef(subregisters !== undefined, selectedProposal);
+    const handleItemSelect = useCallback(((item) => selectProposal(item.itemPath)), [selectProposal]);
+    const activeItem = useMemo((() => selectedProposal
+        ? ({
+            itemPath: selectedProposal,
+            proposal: proposals[selectedProposal],
+            item: (selectedItemProposed !== null && selectedItemProposed !== void 0 ? selectedItemProposed : selectedItemCurrent),
+            itemBefore: selectedItemCurrent !== null && selectedItemCurrent !== void 0 ? selectedItemCurrent : undefined,
+            itemRef: itemPathToItemRef(subregisters !== undefined, selectedProposal),
+        })
+        : null), [selectedProposal, proposals, subregisters]);
+    const allItems = useMemo((() => Object.entries(proposals).map(([itemPath, proposal]) => {
+        var _a, _b;
+        return ({
+            itemPath,
+            proposal,
+            item: (_b = ((_a = getProposedItem(itemPath)) !== null && _a !== void 0 ? _a : getCurrentItem(itemPath))) !== null && _b !== void 0 ? _b : null,
+            itemBefore: undefined,
+            itemRef: itemPathToItemRef(subregisters !== undefined, itemPath),
+        });
+    })), [proposals, getCurrentItem, getProposedItem, subregisters !== undefined]);
+    const haveSelectedItem = selectedProposal
+        && selectedItemRef
+        && proposals[selectedProposal]
+        && (selectedItemProposed || selectedItemCurrent);
+    const proposalCount = Object.keys(proposals).length;
+    //useEffect(() => {
+    //  // if (!selectedProposal) {
+    //  //   const firstProposal = Object.keys(proposals)[0];
+    //  //   if (firstProposal) {
+    //  //     if (getCurrentItem(firstProposal) || getProposedItem(firstProposal)) {
+    //  //       selectProposal(firstProposal);
+    //  //     }
+    //  //   }
+    //  // }
+    //  if (selectedProposal) {
+    //    if (selectedProposalDetailRef.current) {
+    //      selectedProposalDetailRef.current.scrollIntoView({ block: 'center' });
+    //    }
+    //  }
+    //}, [selectedProposal === null]);
+    const selectedItemSummary = haveSelectedItem
+        ? jsx(ProposalSummary, { itemRef: selectedItemRef, item: (selectedItemProposed !== null && selectedItemProposed !== void 0 ? selectedItemProposed : selectedItemCurrent), itemBefore: selectedItemCurrent !== null && selectedItemCurrent !== void 0 ? selectedItemCurrent : undefined, proposal: proposals[selectedProposal] })
+        : jsx(React.Fragment, null, "Select item\u2026");
+    const icon = haveSelectedItem
+        ? getProposalIcon(proposals[selectedProposal])
+        : undefined;
+    const selectedItemDrawer = useMemo((() => {
+        var _a;
+        return jsx(Drawer, { isOpen: proposalCount > 0 && haveSelectedItem ? true : false, onClose: () => selectProposal(null), size: DrawerSize.LARGE, enforceFocus: false }, proposalCount > 0 && haveSelectedItem
+            ? jsx(React.Fragment, null,
+                jsx(ButtonGroup, null,
+                    jsx(Button, { disabled: !jumpTo || (((_a = proposals[selectedProposal]) === null || _a === void 0 ? void 0 : _a.type) === 'addition' && !hadBeenAccepted), icon: 'open-application', onClick: () => jumpTo === null || jumpTo === void 0 ? void 0 : jumpTo(`${Protocols.ITEM_DETAILS}:${selectedProposal}`), title: "Open selected item in a new tab (not applicable to proposed additions)" }),
+                    jsx(ClassNames, null, (({ css: css2 }) => jsx(Select, { filterable: false, itemsEqual: stringifiedJSONEqual, menuProps: { className: css2(`max-height: 50vh; overflow-y: auto;`) }, activeItem: activeItem, items: allItems, popoverProps: { minimal: true, matchTargetWidth: true }, fill: true, itemRenderer: ChangeProposalItemView, onItemSelect: handleItemSelect },
+                        jsx(Button, { fill: true, rightIcon: "chevron-down", icon: icon, title: "Switch between items in this proposal", css: css `white-space: nowrap;` }, selectedItemSummary)))),
+                    jsx(Button, { onClick: () => selectProposal(null), icon: "minimize", title: "Minimize proposed change view", text: "Minimize" })),
+                jsx("div", { css: css `position: relative; flex: 1;` },
+                    jsx(BrowserCtx.Provider, { value: proposalBrowserCtx },
+                        jsx(ErrorBoundary, { viewName: "Proposal detail" },
+                            jsx(ProposalDetail, { itemRef: selectedItemRef, 
+                                //showOnlyChanged={showOnlyChanged}
+                                item: (selectedItemProposed !== null && selectedItemProposed !== void 0 ? selectedItemProposed : selectedItemCurrent), itemBefore: selectedItemCurrent !== null && selectedItemCurrent !== void 0 ? selectedItemCurrent : undefined, proposal: proposals[selectedProposal] })))))
+            : null);
+    }), [proposalCount > 0, haveSelectedItem, selectedItemProposed, selectedItemCurrent, jumpTo, handleItemSelect, selectedProposal && proposals[selectedProposal]]);
+    return (jsx(React.Fragment, null, selectedItemDrawer));
+}
+;
+function stringifiedJSONEqual(i1, i2) {
+    return JSON.stringify(i1) === JSON.stringify(i2);
+}
+export default ProposalBrowser;
+//# sourceMappingURL=ProposalBrowser.js.map

package/compiled/proposals/ProposalDetail.js

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { memo } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Classes, Colors } from '@blueprintjs/core';
+import { InlineDiffGeneric } from '../views/diffing/InlineDiff';
+import useItemClassConfig from '../views/hooks/useItemClassConfig';
+import { ItemDetail } from '../views/detail/RegisterItem';
+export const ProposalDetail = memo(function ({ proposal, showDiff, showOnlyChanged, itemRef, item, itemBefore, onChange }) {
+    var _a;
+    const itemClass = useItemClassConfig((_a = itemRef.classID) !== null && _a !== void 0 ? _a : 'NONEXISTENT_CLASS_ID');
+    if (!itemClass) {
+        throw new Error(`Unknown item class “${itemRef.classID}”!`);
+    }
+    const view = showDiff
+        ? jsx(InlineDiffGeneric, { item1: itemBefore !== null && itemBefore !== void 0 ? itemBefore : {}, item2: item, css: css `
+          position: absolute; inset: 0; padding: 10px; overflow: auto;
+          background-color: white;
+          .bp4-dark & {
+            background-color: ${Colors.DARK_GRAY2};
+          }
+        `, className: `${Classes.ELEVATION_2} ${Classes.RUNNING_TEXT}` })
+        : jsx(ItemDetail, { itemRef: itemRef, item: item, itemBefore: itemBefore, itemClass: itemClass, key: JSON.stringify(itemRef), compactHeader: true });
+    return jsx("div", { css: css `position: absolute; inset: 0; display: flex; flex-flow: column;` }, view);
+});
+export default ProposalDetail;
+//# sourceMappingURL=ProposalDetail.js.map

package/compiled/proposals/ProposalItem.js

@@ -0,0 +1,24 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import { MenuItem } from '@blueprintjs/core';
+import ProposalSummary from './ProposalSummary';
+import ProposalType from './ProposalType';
+export const ChangeProposalItemView = (item, { handleClick, modifiers, query }) => {
+    if (item.item !== null) {
+        const i = item;
+        return (jsx(MenuItem, { active: modifiers.active, disabled: modifiers.disabled, labelElement: jsx(ProposalType, { proposal: i.proposal }), key: item.itemPath, onClick: handleClick, icon: getProposalIcon(item.proposal), text: jsx(ProposalSummary, { ...i }) }));
+    }
+    else {
+        return jsx(MenuItem, { disabled: true, icon: "heart-broken", onClick: handleClick, text: `Broken proposal entry at path ${item.itemPath}` });
+    }
+};
+export default ChangeProposalItemView;
+export function getProposalIcon(proposal) {
+    return proposal.type === 'addition'
+        ? 'add'
+        : proposal.type === 'clarification'
+            ? 'edit'
+            : 'ban-circle';
+}
+//# sourceMappingURL=ProposalItem.js.map

package/compiled/proposals/ProposalSummary.js

@@ -0,0 +1,28 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { useContext } from 'react';
+import { jsx, css } from '@emotion/react';
+import ErrorState from '@riboseinc/paneron-extension-kit/widgets/ErrorState';
+import { BrowserCtx } from '../views/BrowserCtx';
+export const ProposalSummary = function ({ proposal, itemRef, item, itemBefore, onChange }) {
+    var _a;
+    const { itemClasses } = useContext(BrowserCtx);
+    const { classID } = itemRef;
+    const cls = itemClasses[classID];
+    const ListItemView = (_a = cls === null || cls === void 0 ? void 0 : cls.views) === null || _a === void 0 ? void 0 : _a.listItemView;
+    if (ListItemView) {
+        return jsx("span", { css: css `
+      display: inline-flex;
+      flex-flow: row nowrap;
+      align-items: baseline;
+    ` },
+            jsx(ListItemView, { itemRef: itemRef, itemData: item.data, css: css `text-overflow: ellipsis; overflow: hidden;` }),
+            "\u2003",
+            jsx("small", null, cls.meta.title));
+    }
+    else {
+        return jsx(ErrorState, { viewName: "list item view", inline: true, error: "unable to load list item view" });
+    }
+};
+export default ProposalSummary;
+//# sourceMappingURL=ProposalSummary.js.map

package/compiled/proposals/ProposalTab.js

@@ -0,0 +1,89 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useMemo, useState } from 'react';
+import { jsx, css } from '@emotion/react';
+import { UL, } from '@blueprintjs/core';
+import { TabContentsWithHeader, Datestamp } from '../views/util';
+import { isDisposed, hadBeenProposed, hadBeenAccepted } from './types';
+import Workspace from './ProposalWorkspace';
+import ProposalBrowser from './ProposalBrowser';
+const ProposalTab = function ({ proposal, onDeactivate, onDelete, register, stakeholder }) {
+    const pending = !isDisposed(proposal);
+    const proposedMarker = jsx(React.Fragment, null,
+        "Proposed: ",
+        hadBeenProposed(proposal)
+            ? jsx(Datestamp, { date: proposal.timeProposed })
+            : 'not yet');
+    const disposedMarker = jsx(React.Fragment, null,
+        "Disposed: ",
+        !pending
+            ? jsx(Datestamp, { date: proposal.timeDisposed })
+            : 'not yet');
+    const editedMarker = jsx(React.Fragment, null,
+        "Edited: ",
+        jsx(Datestamp, { date: proposal.timeEdited }));
+    const classification = useMemo(() => {
+        var _a;
+        return [{
+                icon: 'lightbulb',
+                children: "Proposal",
+                tooltip: {
+                    icon: 'info-sign',
+                    content: jsx(UL, { css: css `margin: 0;` },
+                        jsx("li", null,
+                            "Proposal ID: ",
+                            proposal.id)),
+                },
+            }, {
+                children: pending
+                    ? jsx(React.Fragment, null, "pending")
+                    : jsx(React.Fragment, null, "disposed"),
+            }, {
+                children: ((_a = proposal.state) === null || _a === void 0 ? void 0 : _a.replaceAll('-', ' ')) || 'N/A',
+                tooltip: {
+                    icon: 'history',
+                    content: jsx(UL, { css: css `margin: 0;` },
+                        jsx("li", null, editedMarker),
+                        jsx("li", null, proposedMarker),
+                        jsx("li", null, disposedMarker)),
+                },
+                intent: proposal.state === 'accepted'
+                    ? 'success'
+                    : proposal.state === 'returned-for-clarification'
+                        ? 'warning'
+                        : proposal.state === 'withdrawn' || proposal.state === 'rejected'
+                            ? 'danger'
+                            : proposal.state === 'draft'
+                                ? undefined
+                                : 'primary',
+            }];
+    }, [
+        proposal.state,
+        pending,
+        editedMarker, proposedMarker, disposedMarker,
+    ]);
+    const [selectedItem, selectItem] = useState(null);
+    const actions = useMemo(() => {
+        const actions = [];
+        if (onDelete) {
+            actions.push({
+                text: "Delete this proposal",
+                onClick: onDelete,
+            });
+        }
+        if (onDeactivate) {
+            actions.push({
+                text: "Exit proposal",
+                title: "Click to deactivate this proposal and leave it as is for now.",
+                intent: "primary",
+                onClick: onDeactivate,
+            });
+        }
+        return actions;
+    }, [onDelete, onDeactivate]);
+    return (jsx(TabContentsWithHeader, { title: jsx(React.Fragment, null, proposal.justification), classification: classification, actions: actions },
+        jsx(Workspace, { proposal: proposal, compareRegisterVersion: !hadBeenAccepted(proposal), register: register, stakeholder: stakeholder, onOpenItem: selectItem }),
+        jsx(ProposalBrowser, { hadBeenAccepted: hadBeenAccepted(proposal), proposals: proposal.items, onSelectItem: selectItem, selectedItem: selectedItem })));
+};
+export default ProposalTab;
+//# sourceMappingURL=ProposalTab.js.map

package/compiled/proposals/ProposalType.js

@@ -0,0 +1,62 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import React, { memo } from 'react';
+import { Tag, } from '@blueprintjs/core';
+import HelpTooltip from '@riboseinc/paneron-extension-kit/widgets/HelpTooltip';
+/** Returns props for a Tag that classifies this proposal. */
+export function proposalToTagProps(proposal) {
+    return {
+        children: proposal.type === 'amendment'
+            ? proposal.amendmentType
+            : proposal.type === 'addition'
+                ? "addition"
+                : proposal.type === 'clarification'
+                    ? "clarification"
+                    : "(unknown proposal type)",
+        intent: proposal.type === 'amendment'
+            ? 'warning'
+            : proposal.type === 'addition' || proposal.type === 'clarification'
+                ? 'primary'
+                : undefined,
+    };
+}
+export function ProposalType({ proposal }) {
+    const proposalConfig = proposal.type === 'amendment'
+        ? PROPOSAL_VIEWS[proposal.amendmentType]
+        : PROPOSAL_VIEWS[proposal.type];
+    //const ProposalTypeLabel: React.FC<ProposalProps<any>> = proposalConfig.summary;
+    const tagProps = proposalToTagProps(proposal);
+    return (jsx(Tag, { minimal: true, ...tagProps, rightIcon: jsx(HelpTooltip, { content: jsx(React.Fragment, null,
+                "Proposed to be ",
+                proposalConfig.hint) }) }));
+}
+const clarification = {
+    hint: jsx(React.Fragment, null, "altered to represent the same concept more clearly."),
+    summary: memo(({ proposal, item, itemRef }) => jsx(React.Fragment, null, "Clarification"), () => true),
+};
+const addition = {
+    hint: jsx(React.Fragment, null, "added to this register."),
+    summary: memo(({ proposal, item, itemRef }) => jsx(React.Fragment, null, "Addition"), () => true),
+};
+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: memo(({ proposal, itemRef, item }) => jsx(React.Fragment, null, "Retirement"), () => true),
+};
+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: memo(({ proposal, itemRef, item }) => jsx(React.Fragment, null, "Supersession"), () => true),
+};
+const invalidation = {
+    hint: jsx(React.Fragment, null, "marked as invalid. The exact semantics of invalidation depend on the register."),
+    summary: memo(({ proposal, itemRef, item }) => jsx(React.Fragment, null, "Invalidation"), () => true),
+};
+const PROPOSAL_VIEWS = {
+    clarification,
+    addition,
+    retirement,
+    supersession,
+    invalidation,
+};
+export default ProposalType;
+//# sourceMappingURL=ProposalType.js.map

package/compiled/proposals/ProposalWorkspace.js

@@ -0,0 +1,70 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { useMemo, useState } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Icon, Checkbox, } from '@blueprintjs/core';
+import { WrappableDL as DL } from '@riboseinc/paneron-extension-kit/widgets/DL';
+import Workspace from '@riboseinc/paneron-extension-kit/widgets/Workspace';
+import SuperSidebar from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/SuperSidebar';
+import Search from '../views/sidebar/Search';
+import { RegisterHelmet as Helmet } from '../views/util';
+import { MATCHES_ANY_CRITERIA } from '../views/FilterCriteria/models';
+import MetaProperties from './MetaProperties';
+import ProposalSearch from './Search';
+import TransitionOptions, { getTransitions, isFinalState } from './TransitionOptions';
+import TransitionsAndStatus, { getTransitionHistory } from './TransitionHistory';
+const SIDEBAR_IDS = ['meta'];
+const ProposalWorkspace = function ({ proposal, compareRegisterVersion, register, stakeholder, onOpenItem }) {
+    const sidebarConfig = useMemo(() => {
+        var _a;
+        return {
+            meta: {
+                icon: () => jsx(Icon, { icon: "document" }),
+                title: "Meta",
+                blocks: [{
+                        key: 'summary',
+                        title: "Summary",
+                        content: jsx("div", { css: css `padding: 0 5px;` },
+                            "\u201C", (_a = proposal.justification) === null || _a === void 0 ? void 0 :
+                            _a.trim(),
+                            "\u201D",
+                            jsx("br", null),
+                            jsx(DL, null,
+                                jsx(MetaProperties, { cr: proposal, currentStakeholder: stakeholder, register: register, compareRegisterVersion: compareRegisterVersion }))),
+                    }, {
+                        key: 'transitions',
+                        title: "Transitions",
+                        content: jsx(TransitionBlockContents, { proposal: proposal, stakeholder: stakeholder }),
+                    }],
+            },
+        };
+    }, [compareRegisterVersion, register, stakeholder, proposal]);
+    return (jsx(Workspace, { sidebarPosition: "right", sidebar: jsx(SuperSidebar, { sidebarIDs: SIDEBAR_IDS, css: css `width: 30% !important; min-width: 300px;`, selectedSidebarID: 'meta', config: sidebarConfig }) },
+        jsx(Helmet, null,
+            jsx("title", null,
+                "Working on proposal ",
+                proposal.justification)),
+        jsx("div", { css: css `padding: 10px; flex: 1; display: flex; flex-flow: column nowrap; overflow: hidden;` },
+            jsx(Search, { css: css `flex: 1;`, 
+                //style={{ height: '100vh', width: '50vw', minWidth: '500px', maxWidth: '90vw' }}
+                implicitCriteria: MATCHES_ANY_CRITERIA, stateName: `proposal-${proposal.id}-search`, List: ProposalSearch, extraData: { proposal }, onOpenItem: onOpenItem }))));
+};
+export default ProposalWorkspace;
+const TransitionBlockContents = function ({ proposal, stakeholder }) {
+    const transitions = useMemo((() => stakeholder
+        ? getTransitions(proposal, stakeholder)
+        : []), [proposal, stakeholder]);
+    const [showDetailedHistory, setShowDetailedHistory] = useState(false);
+    const transitionsBlock = useMemo((() => jsx("div", { css: css `overflow-y: auto; max-height: 300px;` },
+        jsx(Checkbox
+        // NOTE: left margin aligns with transition history bullets…
+        , { 
+            // NOTE: left margin aligns with transition history bullets…
+            css: css `margin: 5px 15px;`, checked: showDetailedHistory, onChange: (evt) => setShowDetailedHistory(evt.currentTarget.checked) }, "Show detailed history"),
+        jsx(TransitionsAndStatus, { pastTransitions: getTransitionHistory(proposal), isFinal: isFinalState(proposal.state), detailed: showDetailedHistory }),
+        !showDetailedHistory && transitions.length > 0
+            ? jsx(TransitionOptions, { stakeholder: stakeholder, transitions: transitions, cr: proposal, css: css `padding: 12px;` })
+            : null)), [proposal, transitions, setShowDetailedHistory, showDetailedHistory]);
+    return transitionsBlock;
+};
+//# sourceMappingURL=ProposalWorkspace.js.map

package/compiled/proposals/Search.js

@@ -0,0 +1,106 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { memo, useContext, useCallback, useMemo } from 'react';
+import { jsx, css } from '@emotion/react';
+import makeList, { LabelledListIcon } from '@riboseinc/paneron-extension-kit/widgets/List';
+import { itemPathInCR, itemPathToItemRef } from '../views/itemPathUtils';
+import { BrowserCtx } from '../views/BrowserCtx';
+const ProposalItem = function ({ onSelect, onOpen, extraData, itemRef: itemPath }) {
+    var _a, _b;
+    const { subregisters, getRelatedItemClassConfiguration } = useContext(BrowserCtx);
+    const proposalItem = extraData.extraItemViewData.proposal.items[itemPath];
+    const registerItem = (_a = extraData.extraItemViewData.itemData[itemPath]) !== null && _a !== void 0 ? _a : null;
+    const itemRef = itemPathToItemRef(subregisters !== undefined, itemPath);
+    const clsConfig = getRelatedItemClassConfiguration(itemRef.classID);
+    const ListItemView = clsConfig === null || clsConfig === void 0 ? void 0 : clsConfig.itemView;
+    const itemPayload = (_b = registerItem === null || registerItem === void 0 ? void 0 : registerItem.data) !== null && _b !== void 0 ? _b : null;
+    const itemView = itemPayload && ListItemView
+        ? jsx(React.Fragment, null,
+            jsx("div", null, clsConfig.title),
+            jsx(ListItemView, { itemData: itemPayload, itemRef: itemRef }))
+        : jsx("span", { css: css `opacity: .4` },
+            "(missing item data at ",
+            itemPath,
+            ")");
+    return (jsx(LabelledListIcon, { contentStyle: { display: 'flex', flexFlow: 'row nowrap', gap: '10px' }, isSelected: extraData.selectedItemPath === itemPath, onSelect: onSelect, onOpen: onOpen, 
+        //contentClassName={(isUpdating && !objData) ? Classes.SKELETON : undefined}
+        entityType: { name: proposalItem.type } }, itemView));
+};
+const List = makeList(ProposalItem);
+export const ProposalSearchResultList = memo(function ({ extraItemViewData, queryExpression, selectedItemPath, onSelectItem, onOpenItem, className }) {
+    const { useRegisterItemData, keyExpression } = useContext(BrowserCtx);
+    const proposal = extraItemViewData.proposal;
+    const proposedItemDataReq = useRegisterItemData({
+        itemPaths: Object.keys(proposal.items),
+    });
+    const itemData = proposedItemDataReq.value;
+    let expressionParsed;
+    try {
+        expressionParsed = new Function('objPath', 'obj', queryExpression);
+    }
+    catch (e) {
+        console.error("Parsing query expression failed", e);
+        expressionParsed = () => false;
+    }
+    const predicate = useCallback(([objPath, obj]) => {
+        const objPathInCR = itemPathInCR(objPath, extraItemViewData.proposal.id);
+        try {
+            return (expressionParsed(objPath, itemData[objPath])
+                || expressionParsed(objPath, obj)
+                || expressionParsed(objPathInCR, itemData[objPath])
+                || expressionParsed(objPathInCR, obj));
+        }
+        catch (e) {
+            console.error("Predicate failed", e);
+            return false;
+        }
+    }, [queryExpression, itemData, extraItemViewData.proposal.id]);
+    const matchingItemIDs = useMemo(() => {
+        let keyExpressionParsed;
+        try {
+            keyExpressionParsed = keyExpression
+                ? new Function('obj', `return ${keyExpression}`)
+                : null;
+        }
+        catch (e) {
+            console.error("Parsing key expression failed", e);
+            keyExpressionParsed = null;
+        }
+        const matchingItems = Object.entries(proposal.items).filter(predicate);
+        const matchingItemsWithKeys = keyExpressionParsed && !proposedItemDataReq.isUpdating
+            ? matchingItems.map(([p,]) => {
+                try {
+                    return [p, keyExpressionParsed(itemData[p])];
+                }
+                catch (e) {
+                    console.debug("Failed to run key expression", keyExpression, p, itemData[p], e);
+                    return [p, p];
+                }
+            })
+            : matchingItems.map(([p,]) => [p, p]);
+        matchingItemsWithKeys.sort((pair1, pair2) => typeof pair1[1] === 'string'
+            ? pair1[1].localeCompare(pair2[1])
+            : typeof pair1[1] === 'number'
+                ? pair1[1] - pair2[1]
+                : 0);
+        return matchingItemsWithKeys.map(([p,]) => p);
+    }, [keyExpression, itemData, predicate, proposal.items]);
+    const extraData = useMemo((() => ({
+        extraItemViewData: { proposal, itemData },
+        selectedItemPath,
+    })), [selectedItemPath, proposal, itemData]);
+    const getListData = useCallback(function _getListData() {
+        return {
+            items: matchingItemIDs,
+            selectedItem: selectedItemPath,
+            selectItem: onSelectItem,
+            openItem: onOpenItem,
+            itemHeight: 32,
+            padding: 0,
+            extraData,
+        };
+    }, [matchingItemIDs.join(','), extraData, onOpenItem, onSelectItem]);
+    return jsx(List, { className: className, getListData: getListData });
+});
+export default ProposalSearchResultList;
+//# sourceMappingURL=Search.js.map