@riboseinc/paneron-registry-kit 2.2.59 → 2.2.60

package/compiled/views/FilterCriteria/mutateGroup.js

@@ -0,0 +1,74 @@
+/**
+ * Mutates given criteria tree in place.
+ * If `path` is empty, guarantees to return a list with at least one item.
+ * (There’s only one top-level element.)
+ */
+export default function mutateGroup(criteria, 
+/**
+ * Parent node path in reverse (top-level index coming last).
+ * Empty path would indicate top-level (which is single and cannot be deleted).
+ */
+path, mutation) {
+    var _a;
+    if (path.length < 1) {
+        if (!((_a = criteria[0]) === null || _a === void 0 ? void 0 : _a.hasOwnProperty('criteria'))) {
+            throw new Error("Top-level item is not a group");
+        }
+        if (mutation.action === 'edit') {
+            // Adjust root criteria group requirement (any/all/none)
+            criteria[0].require = mutation.item.require;
+        }
+        else if (mutation.action === 'delete') {
+            // We MUST NOT delete the singular root critera.
+            // (Calling code depends on there being exactly one top-level group.)
+            // However, we can delete all nested criteria.
+            criteria[0].criteria.splice(0);
+        }
+    }
+    // Other adjustments
+    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,179 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import React, { useRef, useContext, useCallback, useMemo, useState } from 'react';
+import { InputGroup, Button, ControlGroup } from '@blueprintjs/core';
+import { isRegisterItem, } from '../types';
+import { ChangeRequestContext } from '../proposals/ChangeRequestContext';
+import { isDrafted } from '../proposals/types';
+import { BrowserCtx } from './BrowserCtx';
+import ItemSearchDrawer from './ItemSearchDrawer';
+import ItemDetailsDrawer from './ItemDetailsDrawer';
+const DUMMY_REF = {
+    classID: '',
+    itemID: '',
+    subregisterID: '',
+};
+export const GenericRelatedItemView = function ({ itemRef, className, onCreateNew, onClear, onChange, availableClassIDs, onJump, inputRef, controlGroupProps, hideItemClassTitle,
+// availableSubregisterIDs,
+// itemSorter,
+ }) {
+    var _a, _b;
+    const { useRegisterItemData, getRelatedItemClassConfiguration, jumpTo, } = useContext(BrowserCtx);
+    const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+    const { classID, itemID, subregisterID } = itemRef !== null && itemRef !== void 0 ? itemRef : DUMMY_REF;
+    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
+    // TODO: make useRegisterItemData() handle active change request
+    const affectedByActiveCR = (activeChangeRequest &&
+        isDrafted(activeChangeRequest) &&
+        activeChangeRequest.items[itemPathWithSubregister]);
+    const itemPath = affectedByActiveCR
+        ? `/proposals/${activeChangeRequest.id}/items/${itemPathWithSubregister}`
+        : `/${itemPathWithSubregister}`;
+    const [selectDialogState, setSelectDialogState] = useState(false);
+    const [peekingDrawerState, setPeekingDrawerState] = useState(false);
+    //log.debug("Rendering generic related item view", itemRef);
+    //const { jumpToItem } = useContext(BrowserCtx);
+    const itemResult = useRegisterItemData({ itemPaths: [itemPath] });
+    const item = (((_a = itemResult.value) === null || _a === void 0 ? void 0 : _a[itemPath]) || null);
+    const [classConfigured, cfg] = useMemo(() => {
+        let classConfigured;
+        let cfg;
+        try {
+            cfg = getRelatedItemClassConfiguration(classID);
+            classConfigured = true;
+        }
+        catch (e) {
+            cfg = {
+                title: classID,
+                itemView: () => jsx("span", null, itemID)
+            };
+            classConfigured = false;
+        }
+        return [classConfigured, cfg];
+    }, [itemID, classID, getRelatedItemClassConfiguration]);
+    const Item = cfg.itemView;
+    const classIDs = useMemo((() => { var _a; return availableClassIDs !== null && availableClassIDs !== void 0 ? availableClassIDs : (((_a = itemRef === null || itemRef === void 0 ? void 0 : itemRef.classID) !== null && _a !== void 0 ? _a : '') !== '' ? [itemRef.classID] : []); }), [availableClassIDs === null || availableClassIDs === void 0 ? void 0 : availableClassIDs.join(','), itemRef === null || itemRef === void 0 ? void 0 : itemRef.classID]);
+    const itemClassTitle = cfg.title.trim() || null;
+    const hasItem = item !== null && classConfigured && isRegisterItem(item);
+    const itemIsMissing = itemID !== '' && (item === null && !itemResult.isUpdating);
+    const willShowItemView = hasItem || itemIsMissing || !onChange;
+    const canJump = (item !== null || itemIsMissing) && classConfigured && !itemResult.isUpdating && (onJump || jumpTo);
+    const jump = useCallback(function jump() {
+        return onJump
+            ? onJump()
+            : setPeekingDrawerState(true);
+    }, [onJump, jumpTo]);
+    const itemView = useMemo(() => {
+        const classView = jsx("small", { css: css `letter-spacing: -.01em` }, itemClassTitle
+            ? itemClassTitle
+            : jsx("em", null, "unknown class"));
+        const itemView = hasItem
+            ? jsx(Item, { itemRef: { classID, itemID, subregisterID }, itemData: item.data, css: css `overflow: hidden; text-overflow: ellipsis;` })
+            : itemIsMissing
+                ? jsx("span", { css: css `overflow: hidden; text-overflow: ellipsis;` },
+                    "Not found: ", itemID !== null && itemID !== void 0 ? itemID : 'N/A')
+                : jsx("span", null, "Not specified");
+        return jsx(React.Fragment, null,
+            itemView,
+            !hideItemClassTitle ? jsx(React.Fragment, null,
+                "\u2003",
+                classView) : null);
+    }, [itemID, classID, !hideItemClassTitle && itemClassTitle, subregisterID, item === null || item === void 0 ? void 0 : item.data, hasItem, itemIsMissing]);
+    const itemButtons = useMemo(() => {
+        const canAutoCreateRelatedItem = itemID === '' && onCreateNew && !itemResult.isUpdating;
+        const canChangeRelatedItem = /*classIDs.length >= 1 && */ onChange && !itemResult.isUpdating;
+        const canClear = onClear && itemID !== '' && !itemResult.isUpdating;
+        let itemButtons = [];
+        async function handleCreateNew() {
+            if (!onCreateNew) {
+                return;
+            }
+            const itemRef = await onCreateNew();
+            console.debug("Created new item", itemRef);
+        }
+        if (!hasItem && canAutoCreateRelatedItem) {
+            itemButtons.push({
+                onClick: handleCreateNew,
+                icon: 'add',
+                text: 'Auto create',
+                intent: 'primary',
+                title: "Automatically create new item",
+            });
+        }
+        if (canChangeRelatedItem) {
+            itemButtons.push({
+                onClick: () => setSelectDialogState(true),
+                icon: 'edit',
+                text: willShowItemView ? undefined : 'Specify',
+                intent: 'primary',
+                title: "Select related item",
+                /*disabled: classIDs.length < 1,*/
+            });
+        }
+        if (canClear) {
+            itemButtons.push({
+                onClick: onClear,
+                icon: 'eraser',
+                intent: 'danger',
+                title: "Clear related item selection",
+            });
+        }
+        return itemButtons;
+    }, [itemID, itemResult.isUpdating, onCreateNew, onChange, onClear]);
+    const itemTitle = hasItem
+        ? `${itemClassTitle !== null && itemClassTitle !== void 0 ? itemClassTitle : 'unknown class'} item ${itemID !== null && itemID !== void 0 ? itemID : 'with unknown ID'}`
+        : undefined;
+    /** Input ref for using within this component */
+    //const cbRef = useRef<HTMLDivElement | null>(null);
+    const _drawerContainerRef = useRef(null);
+    const closePeekingDrawer = useCallback((() => setPeekingDrawerState(false)), [setPeekingDrawerState]);
+    const _itemRef = useMemo(() => itemRef, [JSON.stringify(itemRef)]);
+    //log.debug("Rendering generic related item view: got item", item);
+    return (jsx(ControlGroup, { dir: "ltr", className: className, title: itemTitle, ...controlGroupProps },
+        jsx(InputGroup, { fill: hasItem, readOnly: !onChange && !onClear, inputRef: inputRef, onChange: useCallback(() => void 0, []), css: css `
+          flex-shrink: 1;
+
+          /* leftElement which displays itemView */
+          .bp4-input-left-container {
+            /* Some obscure magic, since we augment bp4’s styling here. */
+            top: unset;
+            bottom: .42em;
+            padding-left: 10px;
+            padding-right: 5px;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+
+            display: block;
+
+            max-width: 100%;
+          }
+          .bp4-input {
+            /* Hide raw UUID */
+            color: rgba(125, 125, 125, 0);
+            font-family: monospace;
+            padding-left: 0 !important;
+          }
+        `, leftElement: canJump
+                ? jsx("a", { onClick: jump, css: css `
+                  display: flex;
+                  flex-flow: row nowrap;
+                  align-items: baseline;
+                ` }, itemView)
+                : itemView, value: itemID !== null && itemID !== void 0 ? itemID : '', title: itemTitle }),
+        itemButtons.map((props, idx) => jsx(Button, { key: idx, outlined: true, ...props })),
+        jsx(ItemSearchDrawer, { isOpen: selectDialogState, onClose: useCallback(() => setSelectDialogState(false), [setSelectDialogState]), onChooseItem: onChange, availableClassIDs: classIDs }),
+        _itemRef
+            ? jsx(ItemDetailsDrawer, { isOpen: peekingDrawerState, onClose: closePeekingDrawer, itemRef: _itemRef, portalContainer: (_b = _drawerContainerRef.current) !== null && _b !== void 0 ? _b : undefined })
+            : null));
+};
+export default GenericRelatedItemView;
+//# sourceMappingURL=GenericRelatedItemView.js.map

package/compiled/views/ItemDetailsDrawer.js

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import { useContext, useCallback } from 'react';
+import { Button, ButtonGroup, Drawer, DrawerSize } from '@blueprintjs/core';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import MaybeItemDetail from './detail/RegisterItem';
+import { Protocols } from './protocolRegistry';
+import { itemRefToItemPath } from './itemPathUtils';
+const ItemDetailDrawer = function ({ itemRef, usePortal, portalContainer, isOpen, onClose }) {
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const path = itemRefToItemPath(itemRef);
+    return (jsx(Drawer, { isOpen: isOpen, usePortal: usePortal, portalContainer: portalContainer, onClose: onClose, enforceFocus: false, size: DrawerSize.LARGE, css: css `display: flex; flex-flow: column nowrap;`, style: { padding: '0', width: 'unset' } },
+        jsx(ButtonGroup, { fill: true },
+            jsx(Button, { icon: "open-application", onClick: useCallback(() => { onClose(); spawnTab(`${Protocols.ITEM_DETAILS}:${path}`); }, [onClose]), text: "Open in a tab" }),
+            jsx(Button, { icon: "minimize", onClick: onClose, text: "Minimize" })),
+        jsx("div", { css: css `position: relative; flex: 1;` },
+            jsx(MaybeItemDetail.main, { uri: path }))));
+};
+export default ItemDetailDrawer;
+//# sourceMappingURL=ItemDetailsDrawer.js.map

package/compiled/views/ItemSearchDrawer.js

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import { useContext, useMemo, useCallback } from 'react';
+import { Drawer } from '@blueprintjs/core';
+import { BrowserCtx } from './BrowserCtx';
+import Search from './sidebar/Search';
+import { itemPathToItemRef } from './itemPathUtils';
+const ItemSearchDrawer = function ({ isOpen, onClose, onChooseItem, availableClassIDs, }) {
+    const { subregisters } = useContext(BrowserCtx);
+    const classCriteria = useMemo(() => (availableClassIDs.map(clsID => ({
+        key: 'item-class',
+        query: `objPath.indexOf(\"/${clsID}/\") >= 0`,
+    }))), [availableClassIDs.toString()]);
+    const implicitCriteria = useMemo(() => (classCriteria.length > 0
+        ? {
+            require: 'any',
+            criteria: classCriteria,
+        }
+        : undefined), [classCriteria]);
+    const handleOpenItem = useCallback((itemPath) => {
+        onChooseItem === null || onChooseItem === void 0 ? void 0 : onChooseItem(itemPathToItemRef(subregisters !== undefined, itemPath));
+        onClose();
+    }, [onChooseItem, onClose]);
+    return (jsx(Drawer, { isOpen: isOpen, onClose: onClose, enforceFocus: false, size: "50vw", style: { padding: '0', width: 'unset' } },
+        jsx(Search, { style: { height: '100vh', width: '50vw', minWidth: '500px', maxWidth: '90vw' }, availableClassIDs: availableClassIDs, implicitCriteria: implicitCriteria, stateName: "item-browser-search", onOpenItem: onChooseItem ? handleOpenItem : undefined })));
+};
+export default ItemSearchDrawer;
+//# sourceMappingURL=ItemSearchDrawer.js.map

package/compiled/views/Party.js

@@ -0,0 +1,156 @@
+"use strict";
+// /** @jsx jsx */
+// /** @jsxFrag React.Fragment */
+// 
+// import React, { useMemo, useContext } from 'react';
+// import { jsx, css } from '@emotion/react';
+// import { Icon, type IconName, Tag } from '@blueprintjs/core';
+// 
+// import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+// import { BrowserCtx } from './BrowserCtx';
+// import { registerStakeholderPlain } from './RegisterStakeholder';
+// 
+// 
+// const PREFERRED_PARTY_SETTING_NAME = 'preferred_party_id';
+// 
+// 
+// /** Parties that current user can act as, based on chosen remote username. */
+// export function useAvailableParties() {
+//   const { useRemoteUsername } = useContext(DatasetContext);
+//   const { value: { username } } = useRemoteUsername();
+//   const { registerMetadata } = useContext(BrowserCtx);
+//   const parties = registerMetadata?.parties;
+//   // TODO: Sort party IDs by party name?
+//   const partyIDs = parties
+//     ? Object.entries(parties).
+//         filter(([, party]) => party.gitServerUsername === username).
+//         map(([partyID, ]) => partyID).
+//         sort()
+//     : [];
+//   return useMemo(
+//     (() => Object.freeze(partyIDs)),
+//     [partyIDs.join(',')],
+//   );
+// }
+// 
+// function usePreferredPartyID(): string | undefined {
+//   const { useSettings } = useContext(DatasetContext);
+//   const { value: { settings } } = useSettings();
+//   return settings[PREFERRED_PARTY_SETTING_NAME] ?? undefined;
+// }
+// 
+// export function setPreferredPartyID(partyID: string) {
+//   const { updateSetting } = useContext(DatasetContext);
+//   return updateSetting({ key: PREFERRED_PARTY_SETTING_NAME, value: partyID });
+// }
+// 
+// /** Retrieves current user’s active party (preferred or first available). */
+// export function useCurrentUserPartyID() {
+//   const parties = useAvailableParties();
+//   const preferPartyID = usePreferredPartyID();
+// 
+//   if (parties.length < 1) {
+//     return undefined;
+//   } else if (parties.length === 1) {
+//     return parties[0];
+//   } else if (preferPartyID && parties.includes(preferPartyID)) {
+//     return preferPartyID;
+//   } else {
+//     return parties[0];
+//   }
+// }
+// 
+// /** Retrieves full party information about all specified party IDs. */
+// export function useParties(partyIDs: string[]) {
+//   const { registerMetadata } = useContext(BrowserCtx);
+//   const allPartyIDs = Object.keys(registerMetadata?.parties ?? {});
+//   const parties = partyIDs.length < 1 || allPartyIDs.length < 1
+//     ? []
+//     : partyIDs.map(partyID => registerMetadata?.parties?.[partyID]).
+//         filter(party => party !== undefined).
+//         map(p => p!);
+//   return useMemo(
+//     () => Object.freeze(parties),
+//     [partyIDs.join(','), allPartyIDs.join(',')],
+//   )
+// }
+// 
+// /** Retrieves full party information about current user’s active party. */
+// export function useParty() {
+//   const { registerMetadata } = useContext(BrowserCtx);
+//   const partyID = useCurrentUserPartyID();
+//   const parties = registerMetadata?.parties ?? {};
+//   const partyIDs = Object.keys(parties);
+//   const party = partyID && partyIDs.length > 0
+//     ? parties[partyID]
+//     : undefined;
+//   return useMemo(
+//     () => Object.freeze(party),
+//     [partyID, partyIDs.join(',')],
+//   );
+// }
+// 
+// /** Stakeholders that current user’s active party is associated with. */
+// export function useStakeholders() {
+//   const { registerMetadata } = useContext(BrowserCtx);
+//   const party = useParty();
+//   // TODO: Sort stakeholders by name?
+//   const stakeholders = party && registerMetadata?.stakeholders
+//     ? Object.entries(registerMetadata.stakeholders).
+//         filter(([stakeholderID, ]) => party.stakeholderIDs.includes(stakeholderID))
+//     : [];
+//   return useMemo(
+//     () => Object.freeze(stakeholders.map(([, s]) => s)),
+//     [party, stakeholders.map(([sID, ]) => sID).join(',')],
+//   );
+// }
+// 
+// 
+// /** Stakeholder roles that current user’s active party inherit. */
+// export function useRoles() {
+//   const stakeholders = useStakeholders();
+//   const roles = stakeholders.map(s => s.role).sort();
+//   return useMemo(
+//     () => roles,
+//     [roles.join(',')],
+//   );
+// }
+// 
+// 
+// export const PartyView: React.FC<{
+//   partyID: string
+//   markIfCurrentUser?: boolean
+// }> = function ({ partyID, markIfCurrentUser }) {
+//   const { useRemoteUsername } = useContext(DatasetContext);
+//   const { value: { username } } = useRemoteUsername();
+//   const { registerMetadata } = useContext(BrowserCtx);
+//   const party = registerMetadata?.parties[partyID];
+//   if (party && registerMetadata?.stakeholders) {
+//     const stakeholders = Object.entries(registerMetadata?.stakeholders).
+//       filter(([shID, ]) => party.stakeholderIDs.includes(shID)).
+//       map(([, sh]) => sh);
+//     const isCurrentUser = party.gitServerUsername === username;
+//     return <>
+//       <Icon icon={ROLE_ICONS[party.type]} />
+//       &nbsp;
+//       {stakeholders.map(sh =>
+//         <span title="Stakeholder information" css={css`white-space: nowrap;`}>{registerStakeholderPlain(sh)}</span>
+//       ).join(', ')}
+//       &nbsp;
+//       {markIfCurrentUser && isCurrentUser
+//         ? <Tag round minimal intent="primary" css={css`display: inline;`}>
+//             you
+//           </Tag>
+//         : null}
+//     </>;
+//   } else {
+//     return <>N/A</>;
+//   }
+// }
+// 
+// const ROLE_ICONS: Readonly<Record<string, IconName>> = {
+//   'role': 'hat',
+//   'individual': 'person',
+//   'organization': 'office',
+// } as const;
+//# sourceMappingURL=Party.js.map

package/compiled/views/RegisterStakeholder.js

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx, css } from '@emotion/react';
+import { Icon, Tag } from '@blueprintjs/core';
+export const RegisterStakeholderListItem = function ({ stakeholder, isCurrentUser, showRole }) {
+    return jsx("span", null,
+        jsx(Icon, { icon: "person" }),
+        "\u00A0",
+        jsx("span", { title: registerStakeholderPlain(stakeholder, { showRole: true }), css: css `white-space: break-word;` }, registerStakeholderPlain(stakeholder, { showRole })),
+        "\u00A0",
+        isCurrentUser
+            ? jsx(Tag, { round: true, minimal: true, intent: "primary", css: css `display: inline;` }, "you")
+            : null);
+};
+export function registerStakeholderPlain(stakeholder, opts) {
+    return `${stakeholder.name}${(opts === null || opts === void 0 ? void 0 : opts.showRole) ? ` (${formatRole(stakeholder)})` : ''}`;
+}
+function formatRole(stakeholder) {
+    var _a, _b;
+    return `${(_b = (_a = stakeholder.roles) === null || _a === void 0 ? void 0 : _a.join(', ')) !== null && _b !== void 0 ? _b : '(no roles)'}`;
+}
+//# 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,90 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { memo, useMemo, useEffect, useRef, useState, useContext, useCallback } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, ControlGroup, Colors, InputGroup, Tag, ButtonGroup } from '@blueprintjs/core';
+import CriteriaTree from './FilterCriteria';
+import { BLANK_CRITERIA } from './FilterCriteria/models';
+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 = memo(function ({ scope, rootCriteria, onCriteriaChange, quickSearchString, onQuickSearchStringChange, availableClassIDs, className, }) {
+    const { itemClasses, subregisters, stakeholder, getQuickSearchPredicate } = useContext(BrowserCtx);
+    const [editingAdvanced, toggleEditingAdvanced] = useState(false);
+    const classIDs = useMemo((() => availableClassIDs === undefined
+        ? Object.keys(itemClasses)
+        : availableClassIDs), [availableClassIDs, itemClasses]);
+    const hasAdvancedQuery = rootCriteria.criteria.length > 0;
+    const makeDefaultCriteria = useCallback(function makeDefaultCriteria() {
+        if (quickSearchString) {
+            if (getQuickSearchPredicate) {
+                return {
+                    key: 'custom',
+                    query: CUSTOM_CONDITION.toQuery({ customExpression: getQuickSearchPredicate(quickSearchString) }, { itemClasses, subregisters }),
+                };
+            }
+            else {
+                return {
+                    key: 'raw-substring',
+                    query: RAW_SUBSTRING.toQuery({ substring: quickSearchString }, { itemClasses, subregisters }),
+                };
+            }
+        }
+        else {
+            return {
+                key: 'custom',
+                query: CUSTOM_CONDITION.toQuery({ customExpression: 'true' }, { itemClasses, subregisters }),
+            };
+        }
+    }, [quickSearchString, getQuickSearchPredicate, itemClasses, subregisters]);
+    const quickSearchIsEnabled = onQuickSearchStringChange && !hasAdvancedQuery;
+    const quickSearchInputRef = useRef(null);
+    useEffect(() => {
+        if (quickSearchIsEnabled && quickSearchInputRef.current) {
+            quickSearchInputRef.current.focus();
+        }
+    }, []);
+    const quickSearchLabel = scope
+        ? `Quick search across ${scope}`
+        : "Quick search";
+    return (jsx(ControlGroup, { fill: true, vertical: true, className: className },
+        jsx(InputGroup, { fill: true, inputRef: quickSearchInputRef, disabled: !quickSearchIsEnabled, value: hasAdvancedQuery ? '' : quickSearchString, leftIcon: "search", placeholder: quickSearchLabel, title: !hasAdvancedQuery
+                ? "Searching common item attributes (such as names, descriptions, identifiers)."
+                : "Advanced query overrides quick search. Remove advanced query to re-enable.", css: css `width: 200px; ${quickSearchString !== '' && !hasAdvancedQuery ? 'input { font-weight: bold; }' : ''}`, rightElement: !onQuickSearchStringChange || quickSearchString === '' || hasAdvancedQuery
+                ? undefined
+                : jsx(Button, { onClick: () => onQuickSearchStringChange === null || onQuickSearchStringChange === void 0 ? void 0 : onQuickSearchStringChange(''), small: true, minimal: true, icon: "cross", title: "Clear quick search" }), onChange: evt => onQuickSearchStringChange === null || onQuickSearchStringChange === void 0 ? void 0 : onQuickSearchStringChange(evt.currentTarget.value) }),
+        stakeholder
+            ? 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), rightIcon: rootCriteria.criteria.length > 0
+                        ? jsx(Tag, { intent: "success", round: true }, "on")
+                        : jsx(Tag, { round: true }, "off") }, editingAdvanced && hasAdvancedQuery
+                    ? "Advanced search query"
+                    : hasAdvancedQuery
+                        ? "Advanced search query"
+                        : "Enable advanced search"),
+                onCriteriaChange && hasAdvancedQuery
+                    ? jsx(Button, { fill: true, small: true, title: "Remove advanced search query", icon: 'filter-remove', onClick: () => onCriteriaChange(BLANK_CRITERIA) }, "Clear advanced search")
+                    : null)
+            : null,
+        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