@riboseinc/paneron-registry-kit 2.0.0 → 2.0.1

package/compiled/views/FilterCriteria/criteriaToNodes.js

@@ -0,0 +1,89 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import React from 'react';
+import { Button, ButtonGroup, ControlGroup } from '@blueprintjs/core';
+import { Select } from '@riboseinc/paneron-extension-kit/widgets/Sidebar/PropertyView';
+import { isCriteriaGroup, isCriteriaKey } from './models';
+import { CriteriaGroupLabel } from './index';
+import { CRITERIA_CONFIGURATION } from './CRITERIA_CONFIGURATION';
+/**
+ * Builds Blueprint’s tree nodes given criteria,
+ * callbacks and relevant register configuration.
+ */
+export default function criteriaToNodes(cs, opts) {
+    const path = opts.path ?? [];
+    return [...cs.entries()].map(([idx, c]) => {
+        const isRoot = path.length < 1;
+        const defaultIcon = isRoot && opts.implied === true
+            ? 'manual'
+            : undefined;
+        const disabled = opts.implied === true;
+        const deleteButton = idx < (cs.length - 1) && opts.onDeleteItem
+            ? jsx(Button, { minimal: true, small: true, onClick: () => opts.onDeleteItem(path, idx), title: "Delete this criterion or criteria block", disabled: isRoot, icon: "cross" })
+            : null;
+        const addGroupButton = opts.onAddGroup
+            ? jsx(Button, { minimal: true, small: true, title: "Add nested criteria block", icon: "add-to-artifact", onClick: () => opts.onAddGroup([...path, idx]) })
+            : null;
+        if (isCriteriaGroup(c)) {
+            // Render criteria group recursively
+            const cg = c;
+            return {
+                id: `${path.join('-')}-${idx}-${opts.implied}`,
+                disabled,
+                hasCaret: true,
+                isExpanded: true,
+                icon: defaultIcon,
+                label: jsx(CriteriaGroupLabel, { css: css `margin: 2.5px 0`, criteriaGroup: cg, onUpdate: opts.onEditItem
+                        ? ((op) => opts.onEditItem(path, idx, { ...cg, require: op }, true))
+                        : undefined }),
+                secondaryLabel: jsx(ButtonGroup, null,
+                    opts.implied && isRoot ? jsx(React.Fragment, null, "(implied)") : null,
+                    addGroupButton,
+                    deleteButton),
+                childNodes: criteriaToNodes(opts.onEditItem
+                    ? [...cg.criteria, { key: 'custom', query: '' }]
+                    : cg.criteria, { ...opts, path: [...path, idx] }),
+            };
+        }
+        else {
+            // Render leaf criterion
+            const ci = c;
+            const { subregisters, itemClasses } = opts;
+            if (!isCriteriaKey(ci.key)) {
+                console.error("Invalid criteria key encountered", ci.key);
+                throw new Error("Invalid criteria key encountered");
+            }
+            const cfg = CRITERIA_CONFIGURATION[ci.key];
+            if (!cfg) {
+                console.error("Missing criterion configuration for key", ci.key);
+                throw new Error("Missing criterion configuration");
+            }
+            const Widget = cfg.widget;
+            const data = cfg.fromQuery(ci.query, { subregisters, itemClasses });
+            const criterionTypeOptions = Object.entries(CRITERIA_CONFIGURATION).
+                map(([key, cfg]) => {
+                return { value: key, label: cfg.label };
+            });
+            const isPlaceholder = ci.key === 'custom' && ci.query === '';
+            const label = isPlaceholder
+                ? jsx(Button, { small: true, minimal: true, icon: "plus", onClick: () => opts.onEditItem(path, idx, { key: 'custom', query: cfg.toQuery({ customExpression: 'false' }, { subregisters, itemClasses }) }, true) }, "criteria")
+                : jsx(ControlGroup, { vertical: true, css: css `margin-bottom: 2.5px;` },
+                    jsx(Select, { options: criterionTypeOptions, value: ci.key, disabled: !opts.onEditItem, onChange: opts.onEditItem
+                            ? (evt) => {
+                                if (evt.currentTarget.value !== '' && isCriteriaKey(evt.currentTarget.value)) {
+                                    opts.onEditItem(path, idx, { key: evt.currentTarget.value, query: '' });
+                                }
+                            }
+                            : undefined }),
+                    jsx(Widget, { itemClasses: opts.itemClasses, availableClassIDs: opts.availableClassIDs, subregisters: opts.subregisters, data: data, onChange: (val) => opts.onEditItem(path, idx, { key: ci.key, query: cfg.toQuery(val, { subregisters, itemClasses }) }, true) }));
+            return {
+                id: `${path.join('-')}-${idx}-${opts.implied ? 'implied' : ''}`,
+                disabled,
+                label,
+                secondaryLabel: jsx(ButtonGroup, null, deleteButton),
+            };
+        }
+    });
+}
+//# sourceMappingURL=criteriaToNodes.js.map

package/compiled/views/FilterCriteria/index.js

@@ -0,0 +1,75 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import { useEffect, useState } from 'react';
+import { Button, ButtonGroup, Tree } from '@blueprintjs/core';
+import { makeBlankCriteria, COMPOSITION_OPERATORS } from './models';
+import mutateGroup from './mutateGroup';
+import criteriaToNodes from './criteriaToNodes';
+export const SUBREGISTER_PATH_PREFIX = '/subregisters/';
+export const CriteriaTree = function ({ criteria, impliedCriteria, onChange, availableClassIDs, itemClasses, subregisters, className }) {
+    const [crit, updateCriteria] = useState(criteria);
+    useEffect(() => {
+        updateCriteria(criteria);
+    }, [JSON.stringify(criteria)]);
+    function onAddGroup(parent) {
+        const p = reverseArray(parent);
+        var newCriteria = JSON.parse(JSON.stringify([crit]));
+        const newGroup = makeBlankCriteria();
+        mutateGroup(newCriteria, p, { action: 'insert', item: newGroup });
+        updateCriteria(newCriteria[0]);
+        onChange(newCriteria[0]);
+    }
+    function onDelete(parent, idx) {
+        const p = reverseArray(parent);
+        var newCriteria = JSON.parse(JSON.stringify([crit]));
+        mutateGroup(newCriteria, p, { action: 'delete', idx });
+        updateCriteria(newCriteria[0]);
+        onChange(newCriteria[0]);
+    }
+    function onEditItem(parent, idx, newItem, commit) {
+        const p = reverseArray(parent);
+        var newCriteria = JSON.parse(JSON.stringify([crit]));
+        mutateGroup(newCriteria, p, { action: 'edit', idx, item: newItem });
+        updateCriteria(newCriteria[0]);
+        if (commit) {
+            onChange(newCriteria[0]);
+        }
+    }
+    const nodes = criteriaToNodes([crit], {
+        onEditItem: onChange ? onEditItem : undefined,
+        onAddGroup: onChange ? onAddGroup : undefined,
+        onDeleteItem: onChange ? onDelete : undefined,
+        itemClasses,
+        subregisters,
+        availableClassIDs,
+    });
+    const implied = impliedCriteria !== undefined
+        ? criteriaToNodes([impliedCriteria], {
+            implied: true,
+            itemClasses,
+            subregisters,
+            availableClassIDs,
+        })
+        : [];
+    return (jsx(Tree, { contents: [...implied, ...nodes], className: className, css: css `
+        .bp4-tree-node-content { height: unset; }
+        .bp4-tree-node-label { overflow: unset; }
+        .bp4-tree-node-caret, .bp4-tree-node-caret-none { display: none; }
+      ` }));
+};
+export default CriteriaTree;
+export const CriteriaGroupLabel = function ({ criteriaGroup, onUpdate, className }) {
+    return jsx("div", { className: className },
+        onUpdate
+            ? jsx(ButtonGroup, null, COMPOSITION_OPERATORS.map(op => jsx(Button, { key: op, small: true, onClick: () => onUpdate ? onUpdate(op) : void 0, active: criteriaGroup.require === op }, op)))
+            : jsx("strong", null, criteriaGroup.require),
+        " ",
+        "of:");
+};
+function reverseArray(arr) {
+    var copy = JSON.parse(JSON.stringify(arr));
+    copy.reverse();
+    return copy;
+}
+//# sourceMappingURL=index.js.map

package/compiled/views/FilterCriteria/models.js

@@ -0,0 +1,28 @@
+export const COMPOSITION_OPERATORS = [
+    'all',
+    'any',
+    'none',
+];
+// TODO: Can we not hard-code keys here? Would require some smart generic typing.
+const CRITERIA_KEYS = [
+    'item-class',
+    'subregister',
+    'custom',
+    'raw-substring',
+];
+export function isCriteriaKey(val) {
+    return CRITERIA_KEYS.indexOf(val) >= 0;
+}
+export function isCriteriaGroup(val) {
+    return val && val.hasOwnProperty('require') && val.hasOwnProperty('criteria');
+}
+// TODO: Deprecate in favour of `BLANK_CRITERIA`?
+export function makeBlankCriteria() {
+    return BLANK_CRITERIA;
+}
+/** Useful as no-op default where a valid criteria is required. */
+export const BLANK_CRITERIA = {
+    require: 'all',
+    criteria: [],
+};
+//# sourceMappingURL=models.js.map

package/compiled/views/FilterCriteria/mutateGroup.js

@@ -0,0 +1,53 @@
+/** Mutates given criteria tree in place. */
+export default function mutateGroup(criteria, 
+/** Here path must be parent node path in reverse (top-level index coming last). */
+path, mutation) {
+    if (path.length < 1 && mutation.action === 'edit') {
+        criteria[0].require = mutation.item.require;
+    }
+    for (const [curIdx, c] of criteria.entries()) {
+        if (curIdx === path[path.length - 1]) {
+            path.pop();
+            let cg;
+            if (c.hasOwnProperty('criteria')) {
+                // This item is a group, let’s go in and delete descendants
+                cg = c;
+            }
+            else {
+                // This item is a predicate string, can’t go in and delete descendants
+                throw new Error(`Cannot enter item: not a group at path ${path.join('/')}/${curIdx}: ${c}`);
+            }
+            if (path.length > 0) {
+                mutateGroup(cg.criteria, path, mutation);
+            }
+            else {
+                if (mutation.action === 'delete') {
+                    cg.criteria.splice(mutation.idx, 1);
+                }
+                else if (mutation.action === 'insert') {
+                    cg.criteria.push(mutation.item);
+                }
+                else if (mutation.action === 'edit') {
+                    if (cg.criteria[mutation.idx] === undefined && mutation.idx === cg.criteria.length) {
+                        if (mutation.item.hasOwnProperty('require')) {
+                            console.error(cg.criteria, mutation);
+                            throw new Error("Won’t auto-insert new group");
+                        }
+                        // It may be that a new item is being appended
+                        cg.criteria.push(mutation.item);
+                    }
+                    const isGroup = cg.criteria[mutation.idx].hasOwnProperty('require');
+                    if (isGroup) {
+                        // If it’s a group, only change the predicate operator to preserve nested items:
+                        cg.criteria[mutation.idx].require =
+                            mutation.item.require;
+                    }
+                    else {
+                        cg.criteria[mutation.idx] = mutation.item;
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=mutateGroup.js.map

package/compiled/views/GenericRelatedItemView.js

@@ -0,0 +1,147 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import { useContext, useState } from 'react';
+import { Button, ButtonGroup, Dialog } from '@blueprintjs/core';
+import { isRegisterItem, } from '../types';
+import { BrowserCtx } from './BrowserCtx';
+import { ChangeRequestContext } from './change-request/ChangeRequestContext';
+import { isDrafted } from '../types/cr';
+import Search from './sidebar/Search';
+import { itemPathToItemRef } from './itemPathUtils';
+import { Protocols } from './protocolRegistry';
+export const GenericRelatedItemView = function ({ itemRef, className, onCreateNew, onClear, onChange, availableClassIDs, onJump,
+// availableSubregisterIDs,
+// itemSorter,
+ }) {
+    const { useRegisterItemData, getRelatedItemClassConfiguration, jumpTo, } = useContext(BrowserCtx);
+    const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+    const { classID, itemID, subregisterID } = itemRef ?? {
+        classID: '',
+        itemID: '',
+        subregisterID: '',
+    };
+    const itemPathWithClass = `${classID}/${itemID}.yaml`;
+    // If curretn register has subregisters, specify subregister-relative path
+    const itemPathWithSubregister = subregisterID
+        ? `subregisters/${subregisterID}/${itemPathWithClass}`
+        : `${itemPathWithClass}`;
+    // If a change request is active
+    // and this item is among clarifications or additions
+    // then use item path relative to the change request
+    const affectedByActiveCR = (activeChangeRequest &&
+        isDrafted(activeChangeRequest) &&
+        activeChangeRequest.items[itemPathWithSubregister]);
+    const itemPath = affectedByActiveCR
+        ? `/proposals/${activeChangeRequest.id}/items/${itemPathWithSubregister}`
+        : `/${itemPathWithSubregister}`;
+    const [selectDialogState, setSelectDialogState] = useState(false);
+    //log.debug("Rendering generic related item view", itemRef);
+    //const { jumpToItem } = useContext(BrowserCtx);
+    const itemResult = useRegisterItemData({ itemPaths: [itemPath] });
+    const item = (itemResult.value?.[itemPath] || null);
+    let classConfigured;
+    let cfg;
+    try {
+        cfg = getRelatedItemClassConfiguration(classID);
+        classConfigured = true;
+    }
+    catch (e) {
+        cfg = {
+            title: classID,
+            itemView: () => jsx("span", null, itemID)
+        };
+        classConfigured = false;
+    }
+    const Item = cfg.itemView;
+    async function handleCreateNew() {
+        if (!onCreateNew) {
+            return;
+        }
+        const itemRef = await onCreateNew();
+        console.debug("Created new", itemRef);
+    }
+    const classIDs = availableClassIDs ?? ((itemRef?.classID ?? '') !== '' ? [itemRef.classID] : []);
+    function jump() {
+        //jumpToItem?.(classID, itemID, subregisterID);
+        onJump
+            ? onJump()
+            : jumpTo?.(`${Protocols.ITEM_DETAILS}:/${itemPathWithSubregister}`);
+    }
+    const hasItem = item !== null && classConfigured && isRegisterItem(item);
+    const itemIsMissing = itemID !== '' && (item === null && !itemResult.isUpdating);
+    const canAutoCreateRelatedItem = itemID === '' && onCreateNew && !itemResult.isUpdating;
+    const canChangeRelatedItem = /*classIDs.length >= 1 && */ onChange && !itemResult.isUpdating;
+    const canClear = onClear && itemID !== '' && !itemResult.isUpdating;
+    const canJump = item !== null && classConfigured && !itemResult.isUpdating && (onJump || jumpTo);
+    let itemView;
+    let itemButtons = [];
+    if (hasItem) {
+        itemView = jsx(Item, { itemRef: { classID, itemID, subregisterID }, itemData: item.data });
+    }
+    else {
+        if (canAutoCreateRelatedItem) {
+            itemButtons.push({
+                onClick: handleCreateNew,
+                icon: 'add',
+                text: 'Auto create',
+                intent: 'primary',
+            });
+        }
+        if (itemIsMissing) {
+            itemView = jsx("span", null,
+                "Item not found: ",
+                itemID ?? 'N/A');
+        }
+        else {
+            itemView = jsx("span", null, "Item not specified");
+        }
+    }
+    const willShowItemView = hasItem || itemIsMissing || !onChange;
+    if (canChangeRelatedItem) {
+        itemButtons.push({
+            onClick: () => setSelectDialogState(true),
+            icon: 'edit',
+            text: willShowItemView ? undefined : 'Specify',
+            intent: 'primary',
+            /*disabled: classIDs.length < 1,*/
+        });
+    }
+    if (canClear) {
+        itemButtons.push({ onClick: onClear, icon: 'cross', intent: 'danger' });
+    }
+    //log.debug("Rendering generic related item view: got item", item);
+    return (jsx(ButtonGroup, { fill: true, className: className, css: css `.bp4-button-text { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }` },
+        classID
+            ? jsx(Button, { alignText: "left", css: css `width: 180px;`, title: `Item class: ${cfg.title ?? "N/A"}`, outlined: true, disabled: true }, cfg.title ?? "Class N/A")
+            : null,
+        willShowItemView
+            ? jsx(Button, { alignText: "left", fill: hasItem, outlined: true, disabled: !canJump, onClick: jump, loading: itemResult.isUpdating, title: hasItem
+                    ? `${cfg.title} (click to jump to item)`
+                    : undefined }, itemView)
+            : null,
+        itemButtons.map((props, idx) => jsx(Button, { key: idx, outlined: true, ...props })),
+        onChange
+            ? jsx(RelatedItemSelectionDialog, { isOpen: selectDialogState, onClose: () => setSelectDialogState(false), onChange: onChange, availableClassIDs: classIDs })
+            : null));
+};
+const RelatedItemSelectionDialog = function ({ isOpen, onClose, onChange, availableClassIDs, }) {
+    const { subregisters } = useContext(BrowserCtx);
+    const classCriteria = availableClassIDs.map(clsID => ({
+        key: 'item-class',
+        query: `objPath.indexOf(\"/${clsID}/\") >= 0`,
+    }));
+    const implicitCriteria = classCriteria.length > 0
+        ? {
+            require: 'any',
+            criteria: classCriteria,
+        }
+        : undefined;
+    return (jsx(Dialog, { isOpen: isOpen, onClose: onClose, enforceFocus: false, style: { padding: '0', width: 'unset' } },
+        jsx(Search, { style: { height: '90vh', width: '90vw' }, availableClassIDs: availableClassIDs, implicitCriteria: implicitCriteria, stateName: "superseding-item-selector-search", onOpenItem: (itemPath) => {
+                onChange(itemPathToItemRef(subregisters !== undefined, itemPath));
+                onClose();
+            } })));
+};
+export default GenericRelatedItemView;
+//# sourceMappingURL=GenericRelatedItemView.js.map

package/compiled/views/RegisterStakeholder.js

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React from 'react';
+import { jsx, css } from '@emotion/react';
+import { Icon, Tag } from '@blueprintjs/core';
+export const RegisterStakeholderListItem = function ({ stakeholder, isCurrentUser }) {
+    return jsx(React.Fragment, null,
+        jsx(Icon, { icon: "person" }),
+        "\u00A0",
+        jsx("span", { css: css `white-space: nowrap;` }, registerStakeholderPlain(stakeholder)),
+        "\u00A0",
+        isCurrentUser
+            ? jsx(Tag, { round: true, minimal: true, intent: "primary", css: css `display: inline;` }, "you")
+            : null);
+};
+export function registerStakeholderPlain(stakeholder) {
+    return `${stakeholder.name} (${stakeholder.role ?? 'unspecified role'})`;
+}
+//# sourceMappingURL=RegisterStakeholder.js.map

package/compiled/views/RegisterVersion.js

@@ -0,0 +1,20 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React from 'react';
+import { jsx, css } from '@emotion/react';
+import { Tag, Icon } from '@blueprintjs/core';
+import { formatDate } from './util';
+export const RegisterVersion = function ({ version, isCurrent }) {
+    return jsx(React.Fragment, null,
+        jsx(Icon, { icon: "calendar" }),
+        "\u00A0",
+        jsx("span", { css: css `white-space: nowrap;` }, registerVersionPlain(version)),
+        "\u00A0",
+        isCurrent
+            ? jsx(Tag, { round: true, intent: "primary", title: "This version is the current published version." }, "current")
+            : null);
+};
+export function registerVersionPlain(version) {
+    return `${version.id} (published ${formatDate(version.timestamp)})`;
+}
+//# sourceMappingURL=RegisterVersion.js.map

package/compiled/views/SearchQuery.js

@@ -0,0 +1,58 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useState, useContext } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, ControlGroup, Colors, InputGroup, Tag, ButtonGroup } from '@blueprintjs/core';
+import CriteriaTree from './FilterCriteria';
+import { CUSTOM_CONDITION, RAW_SUBSTRING } from './FilterCriteria/CRITERIA_CONFIGURATION';
+import criteriaGroupToQueryExpression from './FilterCriteria/criteriaGroupToQueryExpression';
+//import criteriaGroupToSummary from './FilterCriteria/criteriaGroupToSummary';
+import { BrowserCtx } from './BrowserCtx';
+const SearchQuery = function ({ rootCriteria, onCriteriaChange, quickSearchString, onQuickSearchStringChange, availableClassIDs, className, }) {
+    const { itemClasses, subregisters } = useContext(BrowserCtx);
+    const [editingAdvanced, toggleEditingAdvanced] = useState(false);
+    const classIDs = availableClassIDs ?? Object.keys(itemClasses);
+    const hasAdvancedQuery = rootCriteria.criteria.length > 0;
+    function makeDefaultCriteria() {
+        if (quickSearchString) {
+            return {
+                key: 'raw-substring',
+                query: RAW_SUBSTRING.toQuery({ substring: quickSearchString }, { itemClasses, subregisters }),
+            };
+        }
+        else {
+            return {
+                key: 'custom',
+                query: CUSTOM_CONDITION.toQuery({ customExpression: 'false' }, { itemClasses, subregisters }),
+            };
+        }
+    }
+    return (jsx(ControlGroup, { fill: true, vertical: true, className: className },
+        jsx(InputGroup, { fill: true, small: true, disabled: !onQuickSearchStringChange || hasAdvancedQuery, value: hasAdvancedQuery ? '' : quickSearchString, leftIcon: "search", placeholder: "Quick search", title: !hasAdvancedQuery
+                ? "Search for a substring occurring anywhere within serialized item data."
+                : "Advanced query overrides quick search.", css: css `width: 200px; ${quickSearchString !== '' && !hasAdvancedQuery ? 'input { font-weight: bold; }' : ''}`, rightElement: jsx(Button, { disabled: !onQuickSearchStringChange || quickSearchString === '' || hasAdvancedQuery, onClick: () => onQuickSearchStringChange?.(''), small: true, minimal: true, icon: "cross", title: "Clear quick search" }), onChange: evt => onQuickSearchStringChange?.(evt.currentTarget.value) }),
+        jsx(ButtonGroup, { fill: true },
+            jsx(Button, { fill: true, small: true, title: "Edit advanced search query", icon: 'filter', onClick: !hasAdvancedQuery
+                    ? (() => {
+                        onCriteriaChange({ criteria: [makeDefaultCriteria()], require: 'all' });
+                        toggleEditingAdvanced(true);
+                    })
+                    : () => toggleEditingAdvanced(v => !v), active: editingAdvanced && hasAdvancedQuery, disabled: !hasAdvancedQuery && !onCriteriaChange, rightIcon: rootCriteria.criteria.length > 0
+                    ? jsx(Tag, { intent: "success", round: true }, "on")
+                    : jsx(Tag, { round: true }, "off") }, "Advanced")),
+        hasAdvancedQuery && editingAdvanced
+            ? jsx(React.Fragment, null,
+                jsx(CriteriaTree, { key: "tree", criteria: rootCriteria, onChange: onCriteriaChange, itemClasses: itemClasses, availableClassIDs: classIDs, subregisters: subregisters, css: css `max-height: 50vh; overflow-y: auto;` }),
+                jsx("div", { key: "query", css: css `
+                    margin-top: 5px;
+                    padding: 0 10px 10px 10px;
+                    color: ${Colors.GRAY3};
+                    font-size: 90%;
+                    overflow-wrap: break-word;
+                  ` },
+                    "Query used: ",
+                    jsx("code", null, criteriaGroupToQueryExpression(rootCriteria))))
+            : null));
+};
+export default SearchQuery;
+//# sourceMappingURL=SearchQuery.js.map

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

@@ -0,0 +1,30 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import React, { useContext } from 'react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { canBeEditedBy } from '../../types/cr';
+import { BrowserCtx } from '../BrowserCtx';
+export const ChangeRequestContext = React.createContext({
+    changeRequest: null,
+    canEdit: false,
+});
+export const ChangeRequestContextProvider = function ({ changeRequestID, children }) {
+    const { useObjectData } = useContext(DatasetContext);
+    const { stakeholder } = useContext(BrowserCtx);
+    const crPath = changeRequestID
+        ? `/proposals/${changeRequestID}/main.yaml`
+        : null;
+    const changeRequest = useObjectData({
+        objectPaths: crPath ? [crPath] : [],
+    }).value?.data[crPath ?? ''] ?? (crPath ? undefined : null);
+    return (jsx(ChangeRequestContext.Provider, { value: {
+            changeRequest,
+            canEdit: changeRequest
+                && stakeholder
+                && canBeEditedBy(stakeholder, changeRequest)
+                ? true
+                : false,
+        } }, children));
+};
+//# sourceMappingURL=ChangeRequestContext.js.map