@riboseinc/paneron-registry-kit 2.0.0 → 2.0.1

package/compiled/views/hooks/useItemClassConfig.js

@@ -0,0 +1,14 @@
+import { useContext } from 'react';
+import { BrowserCtx } from '../BrowserCtx';
+export default function useItemClassConfig(clsID) {
+    const { itemClasses } = useContext(BrowserCtx);
+    const clsConfig = itemClasses[clsID];
+    return {
+        value: clsConfig,
+        errors: [],
+        refresh: () => void 0,
+        isUpdating: false,
+        _reqCounter: 0,
+    };
+}
+//# sourceMappingURL=useItemClassConfig.js.map

package/compiled/views/hooks/useItemRef.js

@@ -0,0 +1,26 @@
+import { useContext } from 'react';
+import { BrowserCtx } from '../BrowserCtx';
+import { itemPathToItemRef } from '../itemPathUtils';
+export default function useItemRef(itemPath) {
+    const { subregisters } = useContext(BrowserCtx);
+    try {
+        const value = itemPathToItemRef(subregisters !== undefined, itemPath);
+        return {
+            value,
+            isUpdating: false,
+            refresh: () => void 0,
+            _reqCounter: 0,
+            errors: [],
+        };
+    }
+    catch (e) {
+        return {
+            value: undefined,
+            isUpdating: false,
+            refresh: () => void 0,
+            _reqCounter: 0,
+            errors: [`${e.toString?.() ?? e}`],
+        };
+    }
+}
+//# sourceMappingURL=useItemRef.js.map

package/compiled/views/hooks/useSingleRegisterItemData.js

@@ -0,0 +1,21 @@
+import { useContext } from 'react';
+import { BrowserCtx } from '../BrowserCtx';
+import { itemRefToItemPath } from '../itemPathUtils';
+export default function useSingleRegisterItemData(ref) {
+    const { useRegisterItemData } = useContext(BrowserCtx);
+    const itemPath = ref ? itemRefToItemPath(ref) : 'NONEXISTENT_ITEM';
+    const itemResponse = useRegisterItemData({ itemPaths: [itemPath] });
+    const itemResponseValue = itemResponse.value[itemPath];
+    const itemData = itemResponseValue?.data ?? null;
+    const errMsg = "Item data cannot be loaded";
+    return {
+        value: itemData,
+        errors: itemData === null
+            ? [errMsg, ...itemResponse.errors]
+            : itemResponse.errors,
+        isUpdating: itemResponse.isUpdating,
+        _reqCounter: itemResponse._reqCounter,
+        refresh: itemResponse.refresh,
+    };
+}
+//# sourceMappingURL=useSingleRegisterItemData.js.map

package/compiled/views/index.js

@@ -0,0 +1,142 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useState, useMemo } from 'react';
+import { jsx, css } from '@emotion/react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import TabbedWorkspace from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace';
+import { makeContextProvider as makeTabbedWorkspaceContextProvider, TabbedWorkspaceContext, } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import { isRegisterItem, isRegisterMetadata, isInternalItemReference, } from '../types';
+import { REGISTER_METADATA_FILENAME } from '../common';
+import GenericRelatedItemView from './GenericRelatedItemView';
+import { sidebarConfig, sidebarIDs } from './sidebar';
+import { BrowserCtx } from './BrowserCtx';
+import { _getRelatedClass } from './util';
+import RegisterHome from './detail/RegisterHome';
+import protocolRegistry, { Protocols } from './protocolRegistry';
+import { ChangeRequestContext, ChangeRequestContextProvider, } from './change-request/ChangeRequestContext';
+import { itemPathInCR, itemPathToItemRefLike } from './itemPathUtils';
+export { GenericRelatedItemView };
+const TabbedWorkspaceContextProvider = makeTabbedWorkspaceContextProvider('Browse', sidebarIDs, protocolRegistry);
+export const RegistryView = function (props) {
+    return (jsx(TabbedWorkspaceContextProvider, { stateKey: "main-registry-view" },
+        jsx(BrowserCtxProvider, { ...props },
+            jsx(RegistryWorkspace, null))));
+};
+const RegistryWorkspace = function () {
+    const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const globalMode = useMemo((() => activeChangeRequest
+        ? {
+            content: jsx(React.Fragment, null, "Viewing register as proposed\u2009\u2014\u2009contents shown may differ from version in effect"),
+            intent: 'danger',
+            onClick: () => spawnTab(`${Protocols.CHANGE_REQUEST}:/proposals/${activeChangeRequest.id}/main.yaml`),
+        }
+        : undefined), [activeChangeRequest?.id]);
+    return jsx(TabbedWorkspace, { css: css `flex: 1 1 auto;`, sidebarConfig: sidebarConfig, sidebarIDs: sidebarIDs, newTabPrompt: jsx(RegisterHome, null), globalMode: globalMode });
+};
+const BrowserCtxProvider = function ({ itemClassConfiguration, subregisters, keyExpression, defaultSearchCriteria, customViews, children, }) {
+    const { useObjectData, useRemoteUsername } = useContext(DatasetContext);
+    const { focusedTabURI, spawnTab } = useContext(TabbedWorkspaceContext);
+    const selectedItemPath = focusedTabURI && focusedTabURI.startsWith(`${Protocols.ITEM_DETAILS}:`)
+        ? focusedTabURI.split(':')[1]
+        : null;
+    const selectedItemRef = selectedItemPath
+        ? itemPathToItemRefLike(subregisters !== undefined, selectedItemPath)
+        : null;
+    const maybeSelectedRegisterItemData = useObjectData({
+        objectPaths: selectedItemPath ? [selectedItemPath] : [],
+    }).value.data[selectedItemPath ?? ''];
+    const selectedRegisterItem = isInternalItemReference(selectedItemRef)
+        ? maybeSelectedRegisterItemData &&
+            isRegisterItem(maybeSelectedRegisterItemData)
+            ? {
+                item: maybeSelectedRegisterItemData,
+                ref: selectedItemRef,
+                itemClass: itemClassConfiguration[selectedItemRef.classID],
+            }
+            : undefined
+        : null;
+    // TODO: Confirm that end extensions using RegistryKit can’t just import hooks
+    // from RegistryKit and we really have to pass this to them via context
+    // TODO: Why not use useObjectData directly? Since register item paths
+    // are just object paths. The casting here is optimistic, since an item at given path
+    // may not be a RegisterItem.
+    const useRegisterItemData = (opts) => {
+        // Original item path mapped to its potential alternative path in current CR,
+        // if the item is clarified or added in it.
+        // TODO(perf): Access CR data and check whether the item is affected instead of blindly trying CR paths
+        const pathsToRequest = {};
+        const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+        for (const givenItemPath of opts.itemPaths) {
+            pathsToRequest[givenItemPath] = givenItemPath;
+            // Don’t use CR alternative path for any path that is already explicitly in-CR.
+            // TODO(perf): move out of the loop what’s possible, use map-reduce maybe too
+            if (!opts.ignoreActiveCR && !givenItemPath.startsWith('/proposals') && activeChangeRequest?.id) {
+                pathsToRequest[itemPathInCR(givenItemPath, activeChangeRequest.id)] = givenItemPath;
+            }
+        }
+        const result = useObjectData({
+            objectPaths: Object.keys(pathsToRequest),
+        });
+        const itemData = {};
+        for (const [alternativePath, itemPath] of Object.entries(pathsToRequest)) {
+            const data = result.value.data[alternativePath]
+                ?? result.value.data[itemPath]
+                ?? null;
+            if (isRegisterItem(data) || data === null) {
+                itemData[itemPath] = data;
+            }
+        }
+        // Convert dates
+        // const parsedData: Record<string, RegisterItem<any> | null> = Object.entries(result.value.data).
+        // map(([ path, data ]) => {
+        //   return {
+        //     [path]: data !== null
+        //       ? {
+        //           ...data,
+        //           dateAccepted: parseISO(data!.dateAccepted as unknown as string),
+        //         }
+        //       : null,
+        //   };
+        // }).
+        // reduce((p, c) => ({ ...p, ...c }), {});
+        return {
+            ...result,
+            value: itemData,
+        };
+    };
+    // Register data
+    const registerMetadataReq = useObjectData({
+        objectPaths: [REGISTER_METADATA_FILENAME],
+    });
+    const maybeRegisterMetadata = registerMetadataReq.value.data?.[REGISTER_METADATA_FILENAME] ??
+        (registerMetadataReq.isUpdating ? undefined : null);
+    const registerMetadata = !maybeRegisterMetadata || isRegisterMetadata(maybeRegisterMetadata)
+        ? maybeRegisterMetadata
+        : null;
+    const remoteUsername = useRemoteUsername().value.username;
+    const stakeholder = remoteUsername
+        ? (registerMetadata?.stakeholders ?? []).
+            find(s => s.gitServerUsername === remoteUsername)
+        : undefined;
+    // Active CR
+    const [activeChangeRequestID, setActiveChangeRequestID] = useState(null);
+    const getRelatedClass = _getRelatedClass(itemClassConfiguration);
+    return (jsx(BrowserCtx.Provider, { value: {
+            stakeholder,
+            registerMetadata,
+            subregisters,
+            itemClasses: itemClassConfiguration,
+            jumpTo: spawnTab,
+            selectedRegisterItem,
+            activeChangeRequestID,
+            setActiveChangeRequestID,
+            useRegisterItemData,
+            getRelatedItemClassConfiguration: getRelatedClass,
+            customViews: customViews ?? [],
+            keyExpression,
+            defaultSearchCriteria,
+        } },
+        jsx(ChangeRequestContextProvider, { changeRequestID: activeChangeRequestID }, children)));
+};
+//# sourceMappingURL=index.js.map

package/compiled/views/itemPathUtils.js

@@ -0,0 +1,115 @@
+/**
+ * Returns dataset-relative path to a register item,
+ * given structured item reference.
+ *
+ * Optionally makes path include given change request contents.
+ */
+export function itemRefToItemPath({ subregisterID, classID, itemID }, inCRWithID) {
+    return `${incompleteItemRefToItemPathPrefix({ subregisterID, classID }, inCRWithID)}/${itemID}.yaml`;
+}
+/**
+ * Returns dataset-relative prefix to a register item,
+ * given structured item reference without `itemID`.
+ *
+ * Optionally makes path include given change request contents.
+ */
+export function incompleteItemRefToItemPathPrefix({ subregisterID, classID }, inCRWithID) {
+    const itemWithClass = `${classID}`;
+    const fullPath = subregisterID
+        ? `subregisters/${subregisterID}/${itemWithClass}`
+        : itemWithClass;
+    const maybeInCR = inCRWithID !== undefined
+        ? `/proposals/${inCRWithID}/items/${fullPath}`
+        : `/${fullPath}`;
+    return maybeInCR;
+}
+/**
+ * Attempts to return a structured register item reference
+ * given a dataset-relative item path.
+ * If some components are missing, returns an incomplete reference.
+ */
+export function itemPathToItemRefLike(hasSubregisters, itemPath) {
+    const pathNormalized = itemPath.trim()
+        ? stripLeadingSlash(itemPathNotInCR(itemPath))
+        : undefined;
+    const pathParts = pathNormalized?.split('/') ?? [];
+    const subregisterID = hasSubregisters && pathParts.length >= 1
+        ? pathParts[1]
+        : undefined;
+    const classID = hasSubregisters
+        ? pathParts.length >= 3
+            ? pathParts[2]
+            : undefined
+        : pathParts.length >= 1
+            ? pathParts[0]
+            : undefined;
+    const itemID = (hasSubregisters && pathParts.length === 4) ||
+        (!hasSubregisters && pathParts.length === 2)
+        ? pathParts[pathParts.length - 1].split('.')[0]
+        : undefined;
+    return { subregisterID, classID, itemID };
+}
+/** Returns just register item ID, given dataset-relative path. */
+export function itemPathToItemID(objPath) {
+    const objPathComponents = objPath?.split('/');
+    const selectedItemID = objPathComponents !== undefined
+        ? objPathComponents[objPathComponents.length - 1].split('.')[0]
+        : undefined;
+    return selectedItemID;
+}
+/**
+ * Attempts to return a structured register item reference
+ * given a dataset-relative item path.
+ * If some components are missing, throws an Error.
+ */
+export function itemPathToItemRef(hasSubregisters, itemPath) {
+    const maybeRef = itemPathToItemRefLike(hasSubregisters, itemPath);
+    if (maybeRef.classID && maybeRef.itemID) {
+        return maybeRef;
+    }
+    else {
+        console.error("Internal item reference cannot be constructed from given item path, got", maybeRef, itemPath, hasSubregisters, "from", itemPath);
+        throw new Error("Internal item reference cannot be constructed from given item path");
+    }
+}
+const CR_ITEM_PREFIX_REGEX = /^proposals\/(?<crID>\p{Hex_Digit}{8}(?:-\p{Hex_Digit}{4}){3}-\p{Hex_Digit}{12})\/items\//u;
+/**
+ * If given item path indicates that it is within any CR, returns respective CR ID.
+ * Otherwise, returns `null`.
+ */
+export function getCRIDFromProposedItemPath(givenItemPath) {
+    return stripLeadingSlash(givenItemPath).match(CR_ITEM_PREFIX_REGEX)?.groups?.crID ?? null;
+}
+/**
+ * Given an item path, returns path relative to specified CR ID
+ * (even if the path is already relative to another CR ID).
+ */
+export function itemPathInCR(givenItemPath, crID) {
+    // Remove any CR prefix from given path
+    // TODO(perf): Don’t do if prefix matches CR ID already specified?
+    // TODO: Validate given path actually looks like a register item path and throw?
+    const normalized = stripLeadingSlash(givenItemPath).replace(CR_ITEM_PREFIX_REGEX, '');
+    return `/proposals/${crID}/items/${normalized}`;
+}
+/**
+ * Returns given item path in register-relative form,
+ * even if the path is given within proposal contents.
+ */
+export function itemPathNotInCR(givenItemPath) {
+    const normalized = stripLeadingSlash(givenItemPath).replace(CR_ITEM_PREFIX_REGEX, '');
+    return `/${normalized}`;
+}
+function stripLeadingSlash(aPath) {
+    return aPath.replace(/^\//, '');
+}
+/** Converts a change request ID to dataset-relative path to respective main.yaml. */
+export function crIDToCRPath(crID) {
+    return `/proposals/${crID}/main.yaml`;
+}
+/** Extracts change request ID from dataset-relative path to its main.yaml. */
+export function crPathToCRID(crPath) {
+    return (stripLeadingSlash(crPath).
+        replace('proposals/', '').
+        split('/')[0]);
+}
+//# sourceMappingURL=itemPathUtils.js.map

package/compiled/views/itemQueryUtils.js

@@ -0,0 +1,42 @@
+import { itemPathInCR } from './itemPathUtils';
+// TODO: Should it be three path components? Probably four
+const REGISTER_ITEM_QUERY = `
+  objPath.startsWith("/subregisters/") || (
+    objPath.split("/").length === 3 &&
+    !objPath.startsWith("/proposals/")
+  )
+`;
+/**
+ * Returns a query that matches given register item object path
+ * depending on how it appears in given change request.
+ *
+ * For additions, object path would be full in-proposal path
+ * (the item doesn’t exist in the register “normally”), so we want to match that.
+ * For clarifications, object path we want to match is normal
+ */
+function getItemInCRQuery(cr) {
+    //const affectedItemPathsQuoted: string[] = Object.entries(withCR.items).
+    //  filter(([, proposal]) => proposal.type === 'clarification' || proposal.type === 'addition').
+    //  map(([itemPath, proposal]) => proposal.type === 'clarification' ? `"${itemPath}"` : `/proposals/${withCR.id}/items/${itemPath}`);
+    const affectedItemPathsQuoted = Object.entries(cr.items).
+        filter(([, proposal]) => proposal.type !== 'amendment').
+        map(([itemPath,]) => `"${itemPathInCR(itemPath, cr.id)}"`);
+    return `[${affectedItemPathsQuoted.join(',')}].indexOf(objPath) >= 0`;
+}
+/**
+ * Returns a query criteria for use with filtered indexes
+ * by combining given `queryExpression` with base query that matches only
+ * objects corresponding to register items.
+ *
+ * `withCR` should be set to active CR, and would make the query
+ * additionally match clarified/added register items that did not yet make it
+ * into the register proper.
+ */
+export function getRegisterItemQuery(queryExpression, withCR) {
+    const baseQuery = withCR
+        ? `(${getItemInCRQuery(withCR)}) || (${REGISTER_ITEM_QUERY})`
+        : REGISTER_ITEM_QUERY;
+    // console.debug("CR QUERY", baseQuery);
+    return `return (${baseQuery}) && (${queryExpression.trim()})`;
+}
+//# sourceMappingURL=itemQueryUtils.js.map

package/compiled/views/protocolRegistry.js

@@ -0,0 +1,24 @@
+import RegisterItem from './detail/RegisterItem';
+import RegisterMeta from './detail/RegisterMeta';
+import ChangeRequest from './detail/ChangeRequest';
+import CustomView from './detail/CustomView';
+export const Protocols = {
+    ITEM_DETAILS: 'itemdetails',
+    REGISTER_META: 'registermeta',
+    CHANGE_REQUEST: 'changerequest',
+    CUSTOM_VIEW: 'customview',
+};
+export const protocols = Object.values(Protocols);
+export function isValidProtocol(val) {
+    return protocols.indexOf(val) >= 0;
+}
+// TODO: Implement proper registration pattern rather than registering
+// these in a centralized manner.
+const protocolRegistry = {
+    [Protocols.ITEM_DETAILS]: RegisterItem,
+    [Protocols.REGISTER_META]: RegisterMeta,
+    [Protocols.CHANGE_REQUEST]: ChangeRequest,
+    [Protocols.CUSTOM_VIEW]: CustomView,
+};
+export default protocolRegistry;
+//# sourceMappingURL=protocolRegistry.js.map

package/compiled/views/sidebar/Browse/index.js

@@ -0,0 +1,278 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useEffect } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, Menu, MenuItem, MenuDivider, Tree } from '@blueprintjs/core';
+import { Popover2 } from '@blueprintjs/popover2';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import makeSearchResultList from '@riboseinc/paneron-extension-kit/widgets/SearchResultList';
+import criteriaGroupToQueryExpression from '../../FilterCriteria/criteriaGroupToQueryExpression';
+import CRITERIA_CONFIGURATION from '../../FilterCriteria/CRITERIA_CONFIGURATION';
+import { itemRefToItemPath } from '../../itemPathUtils';
+import { getRegisterItemQuery } from '../../itemQueryUtils';
+import { ChangeRequestContext } from '../../change-request/ChangeRequestContext';
+import { updateCRObjectChangeset } from '../../change-request/objectChangeset';
+import { BrowserCtx } from '../../BrowserCtx';
+import ListItem from '../ListItem';
+import { Protocols } from '../../protocolRegistry';
+const Browse = function ({ stateName, onOpenItem, className, style }) {
+    const { performOperation, updateObjects, makeRandomID, usePersistentDatasetStateReducer } = useContext(DatasetContext);
+    const { spawnTab, focusedTabURI } = useContext(TabbedWorkspaceContext);
+    const { keyExpression, itemClasses, subregisters } = useContext(BrowserCtx);
+    const { changeRequest: activeCR, canEdit: activeCRIsEditable } = useContext(ChangeRequestContext);
+    const [state, dispatch,] = usePersistentDatasetStateReducer(stateName ?? 'browse-sidebar', undefined, function valdateState(loadedValue) {
+        function validateFolderID(foldID) {
+            return foldID !== undefined &&
+                (foldID === null || (foldID.startsWith('by-item-class/') ||
+                    foldID.startsWith('by-subregister/')));
+        }
+        return (validateFolderID(loadedValue.enteredFolderID) &&
+            validateFolderID(loadedValue.selectedFolderID) &&
+            loadedValue.selectedItemPath !== undefined);
+    }, (prevState, action) => {
+        switch (action.type) {
+            case 'select-folder':
+                if (prevState.enteredFolderID !== null) {
+                    return prevState;
+                }
+                else {
+                    return {
+                        ...prevState,
+                        selectedFolderID: action.payload.id,
+                    };
+                }
+            case 'enter-folder':
+                if (prevState.enteredFolderID === null) {
+                    return {
+                        ...prevState,
+                        selectedFolderID: action.payload.id,
+                        enteredFolderID: action.payload.id,
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            case 'exit-folder':
+                if (prevState.enteredFolderID !== null) {
+                    return {
+                        ...prevState,
+                        enteredFolderID: null,
+                        selectedItemPath: null,
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            case 'select-item':
+                if (prevState.enteredFolderID && prevState.selectedFolderID) {
+                    return {
+                        ...prevState,
+                        selectedItemPath: action.payload.itemPath,
+                    };
+                }
+                else {
+                    return prevState;
+                }
+            default:
+                throw new Error("Unexpected browse state");
+        }
+    }, {
+        selectedFolderID: null,
+        enteredFolderID: null,
+        selectedItemPath: null,
+    }, null);
+    // If currently focused tab changed, select corresponding item in view
+    useEffect(() => {
+        if (focusedTabURI) {
+            const [proto, itemPath] = focusedTabURI.split(':');
+            // TODO: also check entered folder?
+            if (proto === Protocols.ITEM_DETAILS) {
+                dispatch({ type: 'select-item', payload: { itemPath } });
+            }
+        }
+    }, [focusedTabURI]);
+    async function handleAdd(classID, subregisterID) {
+        if (!updateObjects || !makeRandomID || !activeCRIsEditable || !activeCR) {
+            throw new Error("Unable to create item: likely current proposal is not editable or dataset is read-only");
+        }
+        if (subregisters && !subregisterID) {
+            throw new Error("Unable to create item: register uses subregisters, but subregister ID was not provided");
+        }
+        const clsConfig = itemClasses[classID];
+        if (!clsConfig) {
+            throw new Error("Unable to generate new item data: item class configuration is missing");
+        }
+        const initialItemData = clsConfig?.defaults ?? {};
+        const itemID = await makeRandomID();
+        const ref = { classID, itemID, subregisterID };
+        const registerItem = {
+            id: itemID,
+            dateAccepted: new Date(),
+            status: 'valid',
+            data: initialItemData,
+        };
+        const itemPath = itemRefToItemPath(ref);
+        await updateObjects({
+            commitMessage: `propose to add new ${ref.classID}`,
+            objectChangeset: updateCRObjectChangeset(activeCR, { [itemPath]: { type: 'addition' } }, { [itemPath]: registerItem }),
+            _dangerouslySkipValidation: true,
+        });
+        spawnTab(`${Protocols.ITEM_DETAILS}:${itemRefToItemPath(ref, activeCR.id)}`);
+    }
+    if (state.enteredFolderID !== null) {
+        // If we are in a folder, show a tree with a single element
+        // indicating currently entered folder
+        // followed by windowed search result list
+        // with query according to the folder (item class, subregister)
+        let criteria;
+        let folderInfo;
+        if (state.enteredFolderID.startsWith('by-item-class/')) {
+            const classID = state.enteredFolderID.split('/')[1];
+            const clsConfig = itemClasses[classID];
+            folderInfo = {
+                title: clsConfig?.meta?.title ?? classID,
+                moreMenu: clsConfig
+                    ? jsx(ItemClassMenu, { cfg: itemClasses[classID], onCreate: !subregisters && activeCRIsEditable && performOperation
+                            ? () => performOperation('generating new item', handleAdd)(classID)
+                            : undefined })
+                    : undefined,
+            };
+            criteria = {
+                require: 'all',
+                criteria: [
+                    {
+                        key: 'item-class',
+                        query: CRITERIA_CONFIGURATION['item-class'].toQuery({ classID }, { itemClasses, subregisters }),
+                    },
+                ],
+            };
+        }
+        else if (subregisters && state.enteredFolderID.startsWith('by-subregister/')) {
+            const subregisterID = state.enteredFolderID.split('/')[1];
+            const subregConfig = subregisters[subregisterID];
+            folderInfo = {
+                title: subregConfig?.title ?? subregisterID,
+                moreMenu: subregConfig
+                    ? jsx(SubregisterMenu, { cfg: subregConfig, itemClasses: itemClasses, onCreate: activeCRIsEditable && performOperation
+                            ? (clsID) => performOperation('generating new item', handleAdd)(clsID, subregisterID)
+                            : undefined })
+                    : undefined,
+            };
+            criteria = {
+                require: 'all',
+                criteria: [
+                    {
+                        key: 'subregister',
+                        query: CRITERIA_CONFIGURATION['subregister'].toQuery({ subregisterID }, { itemClasses, subregisters }),
+                    },
+                ],
+            };
+        }
+        else {
+            folderInfo = { title: '' };
+            criteria = { require: 'all', criteria: [] };
+        }
+        const queryExpression = criteriaGroupToQueryExpression(criteria);
+        return (jsx("div", { css: css `display: flex; flex-flow: column nowrap;`, className: className, style: style },
+            jsx(Tree, { css: css `flex: 0;`, onNodeClick: () => dispatch({ type: 'select-item', payload: { itemPath: null } }), onNodeCollapse: () => dispatch({ type: 'exit-folder' }), onNodeDoubleClick: () => dispatch({ type: 'exit-folder' }), contents: [{
+                        id: 'opened-class',
+                        isSelected: state.selectedItemPath === null,
+                        isExpanded: true,
+                        hasCaret: true,
+                        icon: 'folder-open',
+                        label: folderInfo.title,
+                        secondaryLabel: folderInfo.moreMenu ? jsx(MoreMenu, null, folderInfo.moreMenu) : undefined,
+                    }] }),
+            jsx("div", { css: css `flex: 1;` },
+                jsx(SearchResultList, { queryExpression: getRegisterItemQuery(queryExpression, activeCR ?? undefined), keyExpression: keyExpression, selectedItemPath: state.selectedItemPath, onSelectItem: itemPath => dispatch({ type: 'select-item', payload: { itemPath } }), onOpenItem: onOpenItem ?? (itemPath => spawnTab(`${Protocols.ITEM_DETAILS}:${itemPath}`)) }))));
+    }
+    else {
+        // If we are *not* in a folder, show a list of available folders/views
+        // (item classes, subregisters)
+        const contents = [{
+                id: 'by-item-class',
+                isExpanded: true,
+                hasCaret: false,
+                icon: 'filter',
+                label: "By item class",
+                disabled: true,
+                nodeData: { folderID: null },
+            }, ...Object.entries(itemClasses).map(([classID, classConfig]) => ({
+                isSelected: state.selectedFolderID === `by-item-class/${classID}`,
+                id: classID,
+                isExpanded: false,
+                icon: 'folder-close',
+                hasCaret: true,
+                label: classConfig.meta.title,
+                nodeData: { folderID: `by-item-class/${classID}` },
+                secondaryLabel: jsx(MoreMenu, null,
+                    jsx(ItemClassMenu, { cfg: classConfig, onCreate: !subregisters && activeCRIsEditable && performOperation
+                            ? () => performOperation('generating new item', handleAdd)(classID)
+                            : undefined })),
+            })), ...(subregisters
+                ? [{
+                        id: 'by-subregister',
+                        isExpanded: true,
+                        hasCaret: false,
+                        disabled: true,
+                        icon: 'filter',
+                        label: "By subregister",
+                        nodeData: { folderID: null },
+                    }, ...Object.entries(subregisters).map(([subregisterID, subregisterConfig]) => ({
+                        isSelected: state.selectedFolderID === `by-subregister/${subregisterID}`,
+                        id: subregisterID,
+                        isExpanded: false,
+                        icon: 'folder-close',
+                        hasCaret: true,
+                        label: subregisterConfig.title,
+                        nodeData: { folderID: `by-subregister/${subregisterID}` },
+                        secondaryLabel: jsx(MoreMenu, null,
+                            jsx(SubregisterMenu, { cfg: subregisterConfig, itemClasses: itemClasses, onCreate: activeCRIsEditable && performOperation
+                                    ? (clsID) => performOperation('generating new item', handleAdd)(clsID, subregisterID)
+                                    : undefined })),
+                    }))]
+                : [])
+        ];
+        if (subregisters) {
+            contents.push();
+        }
+        return (jsx(Tree, { css: css `flex: 1;`, className: className, onNodeClick: node => node.nodeData?.folderID
+                ? dispatch({ type: 'select-folder', payload: { id: node.nodeData.folderID } })
+                : void 0, onNodeExpand: node => node.nodeData?.folderID
+                ? dispatch({ type: 'enter-folder', payload: { id: node.nodeData.folderID } })
+                : void 0, onNodeDoubleClick: node => node.nodeData?.folderID
+                ? dispatch({ type: 'enter-folder', payload: { id: node.nodeData.folderID } })
+                : void 0, contents: contents }));
+    }
+};
+const MoreMenu = function ({ children }) {
+    return (jsx(Popover2, { minimal: true, content: jsx(React.Fragment, null, children) },
+        jsx(Button, { icon: "more", small: true, minimal: true })));
+};
+const SubregisterMenu = function ({ cfg, itemClasses, onCreate }) {
+    return (jsx(Menu, null,
+        jsx(MenuDivider, { title: `Item classes in ${cfg.title}` }),
+        cfg.itemClasses.map(classID => jsx(MenuItem, { text: itemClasses[classID]?.meta?.title ?? classID, key: classID },
+            jsx(ItemClassMenu, { cfg: itemClasses[classID], onCreate: onCreate ? () => onCreate(classID) : undefined })))));
+};
+const ItemClassMenu = function ({ cfg, onCreate }) {
+    return (jsx(Menu, null,
+        jsx(MenuDivider, { title: "About this class" }),
+        jsx(MenuItem, { multiline: true, disabled: true, css: css `max-width: 400px`, text: cfg.meta.description }),
+        onCreate
+            ? jsx(React.Fragment, null,
+                jsx(MenuDivider, { title: "Quick actions" }),
+                jsx(MenuItem, { text: "Propose new", intent: "primary", onClick: onCreate, icon: "plus" }))
+            : null));
+};
+const SearchResultList = makeSearchResultList(ListItem, (objPath) => ({
+    name: 'reg. item',
+    iconProps: {
+        icon: 'document',
+        title: objPath,
+        htmlTitle: `Icon for item at ${objPath}`
+    }
+}));
+export default Browse;
+//# sourceMappingURL=index.js.map