@riboseinc/paneron-registry-kit 2.2.58 → 2.2.60

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

@@ -0,0 +1,291 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { memo, useMemo, useCallback, useContext, useEffect } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Menu, MenuItem, MenuDivider, Tree } from '@blueprintjs/core';
+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 { MoreMenu, ItemClassMenu } from '../../util';
+import { itemRefToItemPath } from '../../itemPathUtils';
+import { getRegisterItemQuery } from '../../itemQueryUtils';
+import { ChangeRequestContext } from '../../../proposals/ChangeRequestContext';
+import { updateCRObjectChangeset } from '../../../proposals/objectChangeset';
+import { BrowserCtx } from '../../BrowserCtx';
+import ListItem from '../ListItem';
+import { Protocols } from '../../protocolRegistry';
+const initialState = {
+    selectedFolderID: null,
+    enteredFolderID: null,
+    selectedItemPath: null,
+};
+function validateState(loadedValue) {
+    return (_validateFolderID(loadedValue.enteredFolderID) &&
+        _validateFolderID(loadedValue.selectedFolderID) &&
+        loadedValue.selectedItemPath !== undefined);
+}
+;
+function _validateFolderID(foldID) {
+    return foldID !== undefined &&
+        (foldID === null || (foldID.startsWith('by-item-class/') ||
+            foldID.startsWith('by-subregister/')));
+}
+const Browse = memo(function ({ stateName, onOpenItem, className, style }) {
+    var _a, _b, _c;
+    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 !== null && stateName !== void 0 ? stateName : 'browse-sidebar', undefined, validateState, (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");
+        }
+    }, initialState, 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, dispatch]);
+    const createItem = useCallback(async function _createItem(classID, subregisterID) {
+        var _a;
+        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 = (_a = clsConfig === null || clsConfig === void 0 ? void 0 : clsConfig.defaults) !== null && _a !== void 0 ? _a : {};
+        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)}`);
+    }, [activeCR, activeCRIsEditable, subregisters === undefined, spawnTab, updateObjects, makeRandomID]);
+    const handleSelectItem = useCallback((itemPath => dispatch({ type: 'select-item', payload: { itemPath } })), [dispatch]);
+    const handleDeselectItem = useCallback((() => dispatch({ type: 'select-item', payload: { itemPath: null } })), [dispatch]);
+    const handleOpenItem = useCallback(((itemPath) => (onOpenItem !== null && onOpenItem !== void 0 ? onOpenItem : (itemPath => spawnTab(`${Protocols.ITEM_DETAILS}:${itemPath}`)))(itemPath)), [onOpenItem, spawnTab]);
+    const handleExitFolder = useCallback((() => dispatch({ type: 'exit-folder' })), [dispatch]);
+    const handleAdd = useMemo((() => !subregisters && activeCRIsEditable && performOperation
+        ? (clsID) => performOperation('generating new item', createItem)(clsID)
+        : undefined), [createItem, subregisters === undefined, activeCRIsEditable, performOperation]);
+    const handleAddInSubregister = useMemo((() => subregisters && activeCRIsEditable && performOperation
+        ? (clsID, subregID) => performOperation('generating new item', createItem)(clsID, subregID)
+        : undefined), [createItem, subregisters === undefined, activeCRIsEditable, performOperation]);
+    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: (_b = (_a = clsConfig === null || clsConfig === void 0 ? void 0 : clsConfig.meta) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : classID,
+                moreMenu: clsConfig
+                    ? jsx(ItemClassMenu, { cfg: itemClasses[classID], onCreate: handleAdd ? () => 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: (_c = subregConfig === null || subregConfig === void 0 ? void 0 : subregConfig.title) !== null && _c !== void 0 ? _c : subregisterID,
+                moreMenu: subregConfig
+                    ? jsx(SubregisterMenu, { cfg: subregConfig, itemClasses: itemClasses, onCreate: handleAddInSubregister
+                            ? (clsID) => handleAddInSubregister(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;`, 
+                // This click handler deselects any items in results, meaning.
+                onNodeClick: handleDeselectItem, onNodeCollapse: handleExitFolder, onNodeDoubleClick: handleExitFolder, 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 !== null && activeCR !== void 0 ? activeCR : undefined), keyExpression: keyExpression, selectedItemPath: state.selectedItemPath, onSelectItem: handleSelectItem, onOpenItem: handleOpenItem }))));
+    }
+    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: handleAdd ? () => 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: handleAddInSubregister
+                                    ? (clsID) => handleAddInSubregister(clsID, subregisterID)
+                                    : undefined })),
+                    }))]
+                : [])
+        ];
+        if (subregisters) {
+            contents.push();
+        }
+        return (jsx(Tree, { css: css `flex: 1;`, className: className, onNodeClick: node => {
+                var _a;
+                return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.folderID)
+                    ? dispatch({ type: 'select-folder', payload: { id: node.nodeData.folderID } })
+                    : void 0;
+            }, onNodeExpand: node => {
+                var _a;
+                return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.folderID)
+                    ? dispatch({ type: 'enter-folder', payload: { id: node.nodeData.folderID } })
+                    : void 0;
+            }, onNodeDoubleClick: node => {
+                var _a;
+                return ((_a = node.nodeData) === null || _a === void 0 ? void 0 : _a.folderID)
+                    ? dispatch({ type: 'enter-folder', payload: { id: node.nodeData.folderID } })
+                    : void 0;
+            }, contents: contents }));
+    }
+});
+const SubregisterMenu = memo(function ({ cfg, itemClasses, onCreate }) {
+    return (jsx(Menu, null,
+        jsx(MenuDivider, { title: `Item classes in ${cfg.title}` }),
+        cfg.itemClasses.map(classID => {
+            var _a, _b, _c;
+            return jsx(MenuItem, { text: (_c = (_b = (_a = itemClasses[classID]) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.title) !== null && _c !== void 0 ? _c : classID, key: classID },
+                jsx(ItemClassMenu, { cfg: itemClasses[classID], onCreate: onCreate ? () => onCreate(classID) : undefined }));
+        })));
+});
+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

package/compiled/views/sidebar/ExportImport/ExportOptions.js

@@ -0,0 +1,56 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext } from 'react';
+import { jsx } from '@emotion/react';
+import { Button, ButtonGroup } from '@blueprintjs/core';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { BrowserCtx } from '../../BrowserCtx';
+export const ExportSidebarBlock = function () {
+    var _a, _b, _c;
+    const { writeFileToFilesystem, getObjectData, getBlob } = useContext(DatasetContext);
+    const { selectedRegisterItem, registerMetadata } = useContext(BrowserCtx);
+    const proposedNamePrefix = (selectedRegisterItem === null || selectedRegisterItem === void 0 ? void 0 : selectedRegisterItem.item.id) && (registerMetadata === null || registerMetadata === void 0 ? void 0 : registerMetadata.name)
+        ? `${(_a = registerMetadata.name) !== null && _a !== void 0 ? _a : 'unnamed-register'} item-${selectedRegisterItem.item.id}`
+        : '';
+    async function handleExport(bufferData, filenameExtension) {
+        if (!writeFileToFilesystem) {
+            throw new Error("Unable to export: filesystem write function unavailable");
+        }
+        const separator = proposedNamePrefix && !filenameExtension.startsWith('.')
+            ? ' '
+            : '';
+        const defaultPath = `${proposedNamePrefix}${separator}${filenameExtension}`;
+        await writeFileToFilesystem({
+            dialogOpts: {
+                prompt: "Choose location to export to",
+                defaultPath,
+                filters: [{ name: 'All files', extensions: ['*'] }],
+            },
+            bufferData,
+        });
+    }
+    async function getExportedData(formatConfig) {
+        if (!selectedRegisterItem) {
+            throw new Error("Unable to export item: current item data not available");
+        }
+        if (!getBlob) {
+            throw new Error("Unable to export item: no blob helper");
+        }
+        if (formatConfig) {
+            return await formatConfig.exportItem(selectedRegisterItem.item, { getObjectData, getBlob });
+        }
+        else {
+            return await getBlob(JSON.stringify(selectedRegisterItem.item));
+        }
+    }
+    if (!selectedRegisterItem) {
+        return jsx(React.Fragment, null);
+    }
+    else {
+        return (jsx(ButtonGroup, { vertical: true, fill: true },
+            ((_c = (_b = selectedRegisterItem === null || selectedRegisterItem === void 0 ? void 0 : selectedRegisterItem.itemClass) === null || _b === void 0 ? void 0 : _b.exportFormats) !== null && _c !== void 0 ? _c : []).map((exportFormat, idx) => jsx(Button, { fill: true, key: idx, alignText: "left", onClick: async () => await handleExport(await getExportedData(exportFormat), exportFormat.filenameExtension) }, exportFormat.label)),
+            jsx(Button, { fill: true, alignText: "left", onClick: async () => await handleExport(await getExportedData(), '.json') }, "JSON")));
+    }
+};
+export default ExportSidebarBlock;
+//# sourceMappingURL=ExportOptions.js.map

package/compiled/views/sidebar/ExportImport/ImportOptions.js

@@ -0,0 +1,9 @@
+/** @jsx jsx */
+///** @jsxFrag React.Fragment */
+//import React from 'react';
+import { jsx } from '@emotion/react';
+export const ImportSidebarBlock = function () {
+    return jsx("span", null, "Import TBD");
+};
+export default ImportSidebarBlock;
+//# sourceMappingURL=ImportOptions.js.map

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

@@ -0,0 +1,4 @@
+import ExportOptions from './ExportOptions';
+import ImportOptions from './ImportOptions';
+export { ExportOptions, ImportOptions };
+//# sourceMappingURL=index.js.map

package/compiled/views/sidebar/ListItem.js

@@ -0,0 +1,31 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { memo, useContext } from 'react';
+import { jsx, css } from '@emotion/react';
+import { BrowserCtx } from '../BrowserCtx';
+import { itemPathToItemRef } from '../itemPathUtils';
+/** Register item list view. */
+const ListItem = memo(function ({ objectData, objectPath }) {
+    const { subregisters, getRelatedItemClassConfiguration } = useContext(BrowserCtx);
+    const fallbackView = (jsx("span", { css: css `opacity: .4` },
+        "(missing item data at ",
+        objectPath,
+        ")"));
+    try {
+        const itemRef = itemPathToItemRef(subregisters !== undefined, objectPath);
+        const clsConfig = getRelatedItemClassConfiguration(itemRef.classID);
+        const ListItemView = clsConfig.itemView;
+        const itemPayload = objectData === null || objectData === void 0 ? void 0 : objectData.data;
+        const itemView = itemPayload
+            ? jsx(React.Fragment, null,
+                jsx("div", null, clsConfig.title),
+                jsx(ListItemView, { itemData: itemPayload, itemRef: itemRef }))
+            : fallbackView;
+        return itemView;
+    }
+    catch (e) {
+        return fallbackView;
+    }
+});
+export default ListItem;
+//# sourceMappingURL=ListItem.js.map

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

@@ -0,0 +1,89 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { useEffect, useMemo, useCallback, useContext } from 'react';
+import { jsx } from '@emotion/react';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+//import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import makeSearchResultList from '@riboseinc/paneron-extension-kit/widgets/SearchResultList';
+import { State } from '../../../proposals/types';
+import { CR_BASE_QUERY, DISPOSED_CR_QUERY } from '../../../proposals/queries';
+import { BrowserCtx } from '../../BrowserCtx';
+import { itemRefToItemPath } from '../../itemPathUtils';
+import { ProposalAsListItem } from '../../../proposals/ListItem';
+import { Protocols } from '../../protocolRegistry';
+export const PendingChangeRequestsBlock = function () {
+    const { stakeholder } = useContext(BrowserCtx);
+    const stakeholderUsername = stakeholder === null || stakeholder === void 0 ? void 0 : stakeholder.gitServerUsername;
+    const stakeholderCondition = stakeholderUsername
+        ? `obj.submittingStakeholderGitServerUsername === "${stakeholderUsername}"`
+        : 'false';
+    // Don’t show drafts in the list of pending proposals, unless it’s user’s own drafts.
+    const query = `!obj.timeDisposed && (obj.state !== "draft" || ${stakeholderCondition})`;
+    return jsx(ChangeRequestListBlock, { impliedQuery: query });
+};
+export const ChangeRequestHistoryBlock = function () {
+    return jsx(ChangeRequestListBlock, { impliedQuery: `(${DISPOSED_CR_QUERY}) && (obj.state === "${State.ACCEPTED}" || obj.state === "${State.ACCEPTED_ON_APPEAL}")` });
+};
+const initialState = {
+    quickSubstringQuery: '',
+    selectedItemPath: null,
+};
+export const ChangeRequestListBlock = function ({ impliedQuery, itemPath: _itemPath }) {
+    const { usePersistentDatasetStateReducer } = useContext(DatasetContext);
+    const { spawnTab, focusedTabURI } = useContext(TabbedWorkspaceContext);
+    const { selectedRegisterItem } = useContext(BrowserCtx);
+    const itemPath = _itemPath !== null && _itemPath !== void 0 ? _itemPath : (selectedRegisterItem
+        ? itemRefToItemPath(selectedRegisterItem.ref)
+        : selectedRegisterItem);
+    // ^ Adopt undefined value if no data is available, null if item is not selected
+    const [state, dispatch,] = usePersistentDatasetStateReducer(`change-request-list-block-${itemPath === null ? 'global' : itemPath}-${impliedQuery}`, undefined, undefined, (prevState, action) => {
+        switch (action.type) {
+            case 'update-quick-substring-query':
+                return {
+                    ...prevState,
+                    quickSubstringQuery: action.payload.substring,
+                };
+            case 'select-item':
+                return {
+                    ...prevState,
+                    selectedItemPath: action.payload.itemPath,
+                };
+            default:
+                throw new Error("Unexpected search state");
+        }
+    }, initialState, null);
+    const query = useMemo((() => itemPath
+        ? `return ${CR_BASE_QUERY} && ${impliedQuery} && obj.items["${itemPath}"] !== undefined`
+        : itemPath === null
+            ? `return ${CR_BASE_QUERY} && ${impliedQuery}`
+            // If item data is loading or unavailable, don’t show any CRs
+            // to avoid flashing all CRs during item switching.
+            : `return false`), [impliedQuery, itemPath]);
+    useEffect(() => {
+        const selectedCRPath = focusedTabURI && focusedTabURI.startsWith(`${Protocols.CHANGE_REQUEST}:`)
+            ? focusedTabURI.split(':')[1]
+            : null;
+        if (itemPath !== undefined && selectedCRPath) {
+            setTimeout(() => {
+                dispatch({ type: 'select-item', payload: { itemPath: selectedCRPath } });
+            }, 500);
+        }
+    }, [dispatch, itemPath, focusedTabURI]);
+    return (jsx(ChangeRequestSearchResultList, { queryExpression: query, selectedItemPath: state.selectedItemPath, keyExpression: "(new Date()).getTime() * 100 - (typeof obj.timeDisposed === 'object' ? (obj.timeDisposed ?? new Date()) : new Date(obj.timeDisposed)).getTime() + Math.floor(Math.random() * 1000)", onSelectItem: useCallback((itemPath => dispatch({
+            type: 'select-item',
+            payload: { itemPath },
+        })), [dispatch]), onOpenItem: useCallback((itemPath => spawnTab(`${Protocols.CHANGE_REQUEST}:${itemPath}`)), [spawnTab]) }));
+};
+const CRHistoryItem = function ({ objectData }) {
+    return jsx(ProposalAsListItem, { proposal: objectData });
+};
+const ChangeRequestSearchResultList = makeSearchResultList(CRHistoryItem, (objPath) => ({
+    name: 'Prp.',
+    iconProps: {
+        icon: 'lightbulb',
+        title: objPath,
+        htmlTitle: `icon for proposal at ${objPath}`,
+    },
+}));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,129 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { memo, useContext, useCallback, useMemo, useEffect } from 'react';
+import { jsx, css } from '@emotion/react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { toJSONNormalized } from '@riboseinc/paneron-extension-kit/util';
+import makeSearchResultList from '@riboseinc/paneron-extension-kit/widgets/SearchResultList';
+import useDebounce from '@riboseinc/paneron-extension-kit/useDebounce';
+import { isCriteriaGroup, BLANK_CRITERIA } from '../../FilterCriteria/models';
+import criteriaGroupToQueryExpression from '../../FilterCriteria/criteriaGroupToQueryExpression';
+import { RAW_SUBSTRING, CUSTOM_CONDITION } from '../../FilterCriteria/CRITERIA_CONFIGURATION';
+import { ChangeRequestContext } from '../../../proposals/ChangeRequestContext';
+import { itemRefToItemPath } from '../../itemPathUtils';
+import { getRegisterItemQuery } from '../../itemQueryUtils';
+import { BrowserCtx } from '../../BrowserCtx';
+import SearchQuery from '../../SearchQuery';
+import ListItem from '../ListItem';
+import { Protocols } from '../../protocolRegistry';
+function isState(val) {
+    return val
+        && val.query
+        && val.query.criteria
+        && isCriteriaGroup(val.query.criteria)
+        && typeof val.quickSubstringQuery === 'string'
+        && (val.selectedItemPath === null || typeof val.selectedItemPath === 'string');
+}
+const initialState = {
+    query: { criteria: BLANK_CRITERIA },
+    quickSubstringQuery: '',
+    selectedItemPath: null,
+};
+function isInitialState(state) {
+    return toJSONNormalized(state) === toJSONNormalized(initialState);
+}
+function reducer(prevState, action) {
+    switch (action.type) {
+        case 'update-query':
+            return {
+                ...prevState,
+                query: action.payload.query,
+            };
+        case 'update-quick-substring-query':
+            return {
+                ...prevState,
+                quickSubstringQuery: action.payload.substring,
+            };
+        case 'select-item':
+            return {
+                ...prevState,
+                selectedItemPath: action.payload.itemPath,
+            };
+        default:
+            throw new Error("Unexpected search state");
+    }
+}
+const Search = memo(function ({ scope, implicitCriteria, initialView, zeroResultsView, availableClassIDs, stateName, onOpenItem, List, extraData, className, style }) {
+    const { usePersistentDatasetStateReducer } = useContext(DatasetContext);
+    const ListComponent = useMemo((() => List !== null && List !== void 0 ? List : RegisterItemSearchResultList), [List]);
+    const { 
+    // TODO: defaultSearchCriteria,
+    keyExpression, getQuickSearchPredicate, itemClasses, subregisters, selectedRegisterItem, jumpTo, } = useContext(BrowserCtx);
+    const { changeRequest } = useContext(ChangeRequestContext);
+    const [state, dispatch, stateRecalled] = usePersistentDatasetStateReducer(stateName !== null && stateName !== void 0 ? stateName : 'search-sidebar', undefined, isState, reducer, initialState, null);
+    const selectedItemPath = (selectedRegisterItem === null || selectedRegisterItem === void 0 ? void 0 : selectedRegisterItem.ref)
+        ? itemRefToItemPath(selectedRegisterItem.ref, changeRequest === null || changeRequest === void 0 ? void 0 : changeRequest.id)
+        : null;
+    useEffect(() => {
+        if (selectedItemPath) {
+            dispatch({ type: 'select-item', payload: { itemPath: selectedItemPath } });
+        }
+    }, [selectedItemPath, dispatch]);
+    // Why are we memoing this? It’s just a string and seems not too slow to compute.
+    const effectiveQueryExpression = useMemo(() => {
+        var _a;
+        const quickSearchString = ((_a = state.quickSubstringQuery) !== null && _a !== void 0 ? _a : '').trim();
+        const withSearchString = state.query.criteria.criteria.length < 1 && quickSearchString !== ''
+            ? {
+                require: 'all',
+                criteria: [
+                    getQuickSearchPredicate
+                        ? {
+                            key: 'custom',
+                            query: CUSTOM_CONDITION.toQuery({ customExpression: getQuickSearchPredicate(quickSearchString) }, { itemClasses, subregisters }),
+                        }
+                        : {
+                            key: 'raw-substring',
+                            query: RAW_SUBSTRING.toQuery({ substring: quickSearchString }, { itemClasses, subregisters }),
+                        },
+                ],
+            }
+            : state.query.criteria;
+        const withImplicit = implicitCriteria
+            ? {
+                require: 'all',
+                criteria: [implicitCriteria, withSearchString],
+            }
+            : withSearchString;
+        return withImplicit.criteria.length > 0
+            ? criteriaGroupToQueryExpression(withImplicit)
+            // If no criteria provided, don’t show anything by default.
+            : 'false';
+    }, [state.query.criteria, state.quickSubstringQuery, itemClasses, subregisters, getQuickSearchPredicate]);
+    const stateRecalledDebounced = useDebounce(stateRecalled, 100);
+    const queryExpressionDebounced = useDebounce(effectiveQueryExpression, stateRecalledDebounced ? 500 : 0);
+    const datasetObjectSearchQueryExpression = useMemo((() => queryExpressionDebounced.trim() !== '' && queryExpressionDebounced != 'false'
+        ? getRegisterItemQuery(queryExpressionDebounced, changeRequest !== null && changeRequest !== void 0 ? changeRequest : undefined)
+        : 'return false'), [queryExpressionDebounced, changeRequest]);
+    const handleSelectItem = useCallback((itemPath => dispatch({ type: 'select-item', payload: { itemPath } })), [dispatch]);
+    const defaultHandleOpenItem = useCallback((itemPath => jumpTo === null || jumpTo === void 0 ? void 0 : jumpTo(`${Protocols.ITEM_DETAILS}:${itemPath}`)), [jumpTo]);
+    const handleOpenItem = onOpenItem !== null && onOpenItem !== void 0 ? onOpenItem : defaultHandleOpenItem;
+    const showInitialScreen = initialView && isInitialState({ ...state, selectedItemPath: null });
+    return (jsx("div", { css: css `display: flex; flex-flow: column nowrap;`, className: className, style: style },
+        jsx(SearchQuery, { scope: scope, rootCriteria: state.query.criteria, quickSearchString: state.quickSubstringQuery, availableClassIDs: availableClassIDs, onCriteriaChange: useCallback((criteria => dispatch({ type: 'update-query', payload: { query: { criteria } } })), [dispatch]), onQuickSearchStringChange: useCallback((substring => dispatch({ type: 'update-quick-substring-query', payload: { substring } })), [dispatch]), css: css `padding: 2px; margin-bottom: 10px;` }),
+        jsx("div", { css: css `flex: 1; overflow-y: auto; scrollbar-gutter: stable;` }, showInitialScreen
+            ? initialView
+            : jsx(ListComponent, { queryExpression: datasetObjectSearchQueryExpression, keyExpression: keyExpression, selectedItemPath: state.selectedItemPath, onSelectItem: handleSelectItem, onOpenItem: handleOpenItem, extraItemViewData: extraData, zeroResultsView: effectiveQueryExpression === queryExpressionDebounced
+                    ? zeroResultsView
+                    : undefined }))));
+});
+const RegisterItemSearchResultList = makeSearchResultList(ListItem, (objPath) => ({
+    name: 'reg. item',
+    iconProps: {
+        icon: 'document',
+        title: objPath,
+        htmlTitle: `Icon for item at ${objPath}`,
+    },
+}));
+export default Search;
+//# sourceMappingURL=index.js.map