@riboseinc/paneron-registry-kit 2.2.58 → 2.2.60

package/compiled/views/hooks/useItemRef.js

@@ -0,0 +1,27 @@
+import { useContext } from 'react';
+import { BrowserCtx } from '../BrowserCtx';
+import { itemPathToItemRef } from '../itemPathUtils';
+export default function useItemRef(itemPath) {
+    var _a, _b;
+    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: [`${(_b = (_a = e.toString) === null || _a === void 0 ? void 0 : _a.call(e)) !== null && _b !== void 0 ? _b : e}`],
+        };
+    }
+}
+//# sourceMappingURL=useItemRef.js.map

package/compiled/views/hooks/useLatestAcceptedProposal.js

@@ -0,0 +1,39 @@
+import { useContext } from 'react';
+import { isObject } from '@riboseinc/paneron-extension-kit/util';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { CR_BASE_QUERY } from '../../proposals/queries';
+import { State, isAccepted, isAcceptedOnAppeal, } from '../../proposals/types';
+export default function useLatestAcceptedProposal() {
+    const { useMapReducedData } = useContext(DatasetContext);
+    const latestAcceptedProposalDisposedTimestamp = useMapReducedData({
+        chains: {
+            unnamedChain: {
+                predicateFunc: `
+          const objPath = key, obj = value;
+          return (${CR_BASE_QUERY} && obj.timeDisposed && ['${State.ACCEPTED}', '${State.ACCEPTED_ON_APPEAL}'].indexOf(obj.state) >= 0);
+	`,
+                mapFunc: `emit({ ...value, timeDisposed: new Date(value.timeDisposed) });`,
+                reduceFunc: `
+	  if (!accumulator.timeDisposed || value.timeDisposed > accumulator.timeDisposed) {
+	    return value;
+	  }
+	  else { return accumulator; }
+	`,
+            },
+        },
+    });
+    const result = latestAcceptedProposalDisposedTimestamp.value.unnamedChain;
+    if (result && isObject(result) && Object.keys(result).length > 0) {
+        if (isAccepted(result) || isAcceptedOnAppeal(result)) {
+            return result;
+        }
+        else {
+            throw new Error("Failed to obtain latest accepted proposal: invalid proposal shape");
+        }
+    }
+    else {
+        return null;
+        //throw new Error("Failed to obtain latest accepted proposal: possibly none exist")
+    }
+}
+//# sourceMappingURL=useLatestAcceptedProposal.js.map

package/compiled/views/hooks/useRegisterVersion.js

@@ -0,0 +1,35 @@
+import { useContext } from 'react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { CR_BASE_QUERY } from '../../proposals/queries';
+import { State } from '../../proposals/types';
+/**
+ * By “register version” in this case
+ * the date of latest accepted proposal is meant.
+ */
+export default function useRegisterVersion() {
+    const { useMapReducedData } = useContext(DatasetContext);
+    const latestAcceptedProposalDisposedTimestamp = useMapReducedData({
+        chains: {
+            unnamedChain: {
+                predicateFunc: `
+          const objPath = key, obj = value;
+          return (${CR_BASE_QUERY} && ['${State.ACCEPTED}', '${State.ACCEPTED_ON_APPEAL}'].indexOf(obj.state) >= 0);
+	`,
+                mapFunc: `if (value?.timeDisposed) emit(new Date(value.timeDisposed));`,
+                reduceFunc: `
+	  if (!accumulator || value > accumulator) { return value; }
+	  else { return accumulator; }
+	`,
+            },
+        },
+    });
+    const result = latestAcceptedProposalDisposedTimestamp.value.unnamedChain;
+    if (result && result.getSeconds !== undefined) {
+        return result;
+    }
+    else {
+        //console.error("Invalid register version value", result);
+        throw new Error("Failed to obtain register version (obtained value is not a timestamp)");
+    }
+}
+//# sourceMappingURL=useRegisterVersion.js.map

package/compiled/views/hooks/useSingleRegisterItemData.js

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

package/compiled/views/hooks/useStakeholder.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=useStakeholder.js.map

package/compiled/views/index.js

@@ -0,0 +1,247 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useCallback, useState, useMemo } from 'react';
+import { useDebounce } from 'use-debounce';
+import { jsx, css } from '@emotion/react';
+import { Helmet } from 'react-helmet';
+import { Colors } from '@blueprintjs/core';
+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, } from '../types';
+import { REGISTER_METADATA_FILENAME } from '../common';
+import GenericRelatedItemView from './GenericRelatedItemView';
+import { BrowserCtx } from './BrowserCtx';
+import { Datestamp, _getRelatedClass } from './util';
+import RegisterHome from './detail/RegisterHome2';
+import protocolRegistry, { Protocols } from './protocolRegistry';
+import { ChangeRequestContext, ChangeRequestContextProvider, } from '../proposals/ChangeRequestContext';
+import useRegisterVersion from './hooks/useRegisterVersion';
+import { sidebarConfig, sidebarConfigForStakeholder } from './sidebar';
+import { useItemRef, itemPathInCR, itemPathNotInCR } from './itemPathUtils';
+export { GenericRelatedItemView };
+const TabbedWorkspaceContextProvider = makeTabbedWorkspaceContextProvider(undefined, [], protocolRegistry);
+export const RegistryView = function RegistryView(props) {
+    const Workspace = useMemo(() => { var _a; return (_a = props.CustomWorkspace) !== null && _a !== void 0 ? _a : RegistryWorkspace; }, []);
+    return (jsx(TabbedWorkspaceContextProvider, { stateKey: "main-registry-view" },
+        jsx(BrowserCtxProvider, { ...props },
+            jsx(Workspace, null))));
+};
+export const SIDEBAR_WIDTH_SETTING_NAME = 'registryMainSidebarWidthPixels';
+const RegistryWorkspace = function RegistryWorkspace() {
+    var _a, _b;
+    const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const { registerMetadata, stakeholder } = useContext(BrowserCtx);
+    const { useSettings, updateSetting, useGlobalSettings } = useContext(DatasetContext);
+    let version;
+    try {
+        version = jsx(React.Fragment, null,
+            "Viewing register as of ",
+            jsx("span", { title: "Date of latest accepted proposal" },
+                jsx(Datestamp, { date: useRegisterVersion(), showTime: true, useUTC: true })));
+    }
+    catch (e) {
+        //console.error("Failed to get register version", e);
+        version = jsx(React.Fragment, null, "Viewing published register (version not available)");
+    }
+    const globalMode = useMemo((() => activeChangeRequest
+        ? {
+            content: jsx(React.Fragment, null,
+                "Viewing register as proposed per \u201C",
+                jsx("span", { title: "Justification of active proposal" }, activeChangeRequest.justification),
+                "\u201D"),
+            intent: 'danger',
+            onClick: () => spawnTab(Protocols.PROPOSAL_WORK),
+        }
+        : {
+            content: version,
+            intent: 'none',
+            minimal: true,
+        }), [activeChangeRequest === null || activeChangeRequest === void 0 ? void 0 : activeChangeRequest.id, spawnTab, version]);
+    const { value: { settings } } = useSettings();
+    const { value: { settings: globalSettings } } = useGlobalSettings();
+    const stored = settings[SIDEBAR_WIDTH_SETTING_NAME];
+    const sidebarWidth = stored && typeof stored === 'number'
+        ? stored
+        : undefined;
+    const activeSidebarConfig = useMemo((() => stakeholder ? sidebarConfigForStakeholder : sidebarConfig), [stakeholder]);
+    return (jsx("div", { css: css `flex: 1 1 auto; display: flex; flex-flow: column nowrap; overflow: hidden;` },
+        jsx(Helmet, null,
+            jsx("title", null, (_a = registerMetadata === null || registerMetadata === void 0 ? void 0 : registerMetadata.name) !== null && _a !== void 0 ? _a : "Unnamed registry")),
+        jsx("header", { css: css `
+            min-height: 2em;
+            flex: 0;
+            line-height: 1;
+            font-size: 200%;
+            background: ${Colors.LIGHT_GRAY2};
+            padding: .5em 20px;
+            .bp4-dark & {
+              background: ${Colors.DARK_GRAY2};
+            }
+            display: flex;
+            flex-flow: row nowrap;
+          ` },
+            jsx("h1", { css: css `
+              line-height: unset !important;
+              font-size: unset !important;
+              font-weight: bold;
+              color: ${Colors.DARK_GRAY5};
+              .bp4-dark & {
+                color: ${Colors.LIGHT_GRAY3};
+              }
+              margin: 0;
+              flex: 1;
+              letter-spacing: -.025em;
+            ` }, (_b = registerMetadata === null || registerMetadata === void 0 ? void 0 : registerMetadata.name) !== null && _b !== void 0 ? _b : 'Register')),
+        jsx(TabbedWorkspace, { css: css `flex: 1 1 auto;`, sidebarConfig: activeSidebarConfig, sidebarPosition: globalSettings.sidebarPosition, sidebarIDs: useMemo(() => ['Browse'], []), newTabPrompt: newTabPrompt, globalMode: globalMode, sidebarWidth: sidebarWidth, onSidebarResize: useCallback((width) => {
+                updateSetting({ key: SIDEBAR_WIDTH_SETTING_NAME, value: width });
+            }, [updateSetting]) })));
+};
+const newTabPrompt = jsx(RegisterHome, null);
+const BrowserCtxProvider = function BrowserCtxProvider({ itemClassConfiguration, itemClassGroups, subregisters, keyExpression, defaultSearchCriteria, getQuickSearchPredicate, alterApprovedCR, customViews, children, }) {
+    var _a, _b;
+    const { useObjectData, useRemoteUsername } = useContext(DatasetContext);
+    const { focusedTabURI, spawnTab } = useContext(TabbedWorkspaceContext);
+    // Active item
+    const selectedItemPath = useMemo((() => focusedTabURI && focusedTabURI.startsWith(`${Protocols.ITEM_DETAILS}:`)
+        ? focusedTabURI.split(':')[1]
+        : null), [focusedTabURI]);
+    const selectedItemRef = useItemRef(subregisters !== undefined, selectedItemPath);
+    const maybeSelectedRegisterItemData = useObjectData({
+        objectPaths: selectedItemPath ? [selectedItemPath] : [],
+    }).value.data[selectedItemPath !== null && selectedItemPath !== void 0 ? selectedItemPath : ''];
+    const selectedRegisterItem = useMemo((() => selectedItemRef
+        ? maybeSelectedRegisterItemData &&
+            isRegisterItem(maybeSelectedRegisterItemData)
+            ? {
+                item: maybeSelectedRegisterItemData,
+                ref: selectedItemRef,
+                itemClass: itemClassConfiguration[selectedItemRef.classID],
+            }
+            : undefined
+        : null), [selectedItemRef, maybeSelectedRegisterItemData]);
+    // Active CR
+    const [activeChangeRequestID, setActiveChangeRequestID] = useState(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 = useCallback((opts) => {
+        const { changeRequest: activeChangeRequest } = useContext(ChangeRequestContext);
+        // 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 = useMemo(() => {
+            const pathsToRequest = {};
+            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 === null || activeChangeRequest === void 0 ? void 0 : activeChangeRequest.id)) {
+                    pathsToRequest[itemPathInCR(givenItemPath, activeChangeRequest.id)] = givenItemPath;
+                }
+            }
+            return pathsToRequest;
+        }, [activeChangeRequest === null || activeChangeRequest === void 0 ? void 0 : activeChangeRequest.id, opts.itemPaths.sort().toString()]);
+        const objectPaths = Object.keys(pathsToRequest).sort();
+        const result = useObjectData({
+            objectPaths,
+            //nounLabel: 'register item(s)',
+        });
+        const itemData = useMemo(() => {
+            var _a, _b;
+            const itemData = {};
+            for (const [alternativePath, itemPath] of Object.entries(pathsToRequest)) {
+                const data = (_b = (_a = result.value.data[alternativePath]) !== null && _a !== void 0 ? _a : result.value.data[itemPath]) !== null && _b !== void 0 ? _b : null;
+                if (isRegisterItem(data) || data === null) {
+                    itemData[itemPath] = data;
+                }
+            }
+            return itemData;
+        }, [pathsToRequest, result.value.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,
+        };
+    }, [useObjectData, activeChangeRequestID]);
+    // Register data
+    const registerMetadataReq = useObjectData({
+        objectPaths: [REGISTER_METADATA_FILENAME],
+        nounLabel: 'register meta',
+    });
+    const maybeRegisterMetadata = (_b = (_a = registerMetadataReq.value.data) === null || _a === void 0 ? void 0 : _a[REGISTER_METADATA_FILENAME]) !== null && _b !== void 0 ? _b : (registerMetadataReq.isUpdating ? undefined : null);
+    const registerMetadata = !maybeRegisterMetadata || isRegisterMetadata(maybeRegisterMetadata)
+        ? maybeRegisterMetadata
+        : null;
+    const remoteUsername = useRemoteUsername().value.username;
+    const stakeholder = useMemo((() => {
+        var _a;
+        return remoteUsername
+            ? ((_a = registerMetadata === null || registerMetadata === void 0 ? void 0 : registerMetadata.stakeholders) !== null && _a !== void 0 ? _a : []).
+                find(s => s.gitServerUsername === remoteUsername)
+            : undefined;
+    }), [remoteUsername, registerMetadata]);
+    const getRelatedItemClassConfiguration = useMemo((() => _getRelatedClass(itemClassConfiguration)), [itemClassConfiguration]);
+    const [activeChangeRequestIDDebounced] = useDebounce(activeChangeRequestID, 200);
+    const customViewsMemoized = useMemo((() => customViews !== null && customViews !== void 0 ? customViews : []), [customViews]);
+    const handleJumpTo = useCallback((uri) => {
+        if (activeChangeRequestID && uri.startsWith(`${Protocols.ITEM_DETAILS}:/proposal`)) {
+            const uriNotInCR = itemPathNotInCR(uri.split(`${Protocols.ITEM_DETAILS}:`)[1]);
+            return spawnTab(`${Protocols.ITEM_DETAILS}:${uriNotInCR}`);
+        }
+        else {
+            return spawnTab(uri);
+        }
+    }, [spawnTab, activeChangeRequestID]);
+    return (jsx(BrowserCtx.Provider, { value: useMemo((() => ({
+            stakeholder,
+            registerMetadata,
+            offline: remoteUsername === undefined ? true : undefined,
+            subregisters,
+            alterApprovedCR,
+            itemClasses: itemClassConfiguration,
+            itemClassGroups,
+            jumpTo: handleJumpTo,
+            selectedRegisterItem,
+            activeChangeRequestID: activeChangeRequestIDDebounced,
+            setActiveChangeRequestID,
+            useRegisterItemData,
+            getRelatedItemClassConfiguration,
+            customViews: customViewsMemoized,
+            keyExpression,
+            defaultSearchCriteria,
+            getQuickSearchPredicate,
+        })), [
+            selectedRegisterItem,
+            activeChangeRequestIDDebounced,
+            stakeholder,
+            registerMetadata,
+            remoteUsername,
+            subregisters,
+            handleJumpTo,
+            useRegisterItemData,
+            customViewsMemoized,
+            itemClassConfiguration,
+            subregisters,
+            keyExpression,
+            defaultSearchCriteria,
+            getQuickSearchPredicate,
+        ]) },
+        jsx(ChangeRequestContextProvider, { changeRequestID: activeChangeRequestIDDebounced }, children)));
+};
+//# sourceMappingURL=index.js.map

package/compiled/views/itemPathUtils.js

@@ -0,0 +1,139 @@
+import { useMemo } from 'react';
+import { isInternalItemReference } from '../types';
+/**
+ * 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;
+}
+/**
+ * Gives memoized structured item reference or `null`,
+ * given subregisters and `itemPath`.
+ */
+export function useItemRef(hasSubregisters, itemPath) {
+    return useMemo(() => {
+        if (itemPath) {
+            const maybeItemRef = itemPathToItemRefLike(hasSubregisters, itemPath);
+            if (isInternalItemReference(maybeItemRef)) {
+                return maybeItemRef;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }, [hasSubregisters, itemPath]);
+}
+/**
+ * Attempts to return a structured register item reference
+ * given a dataset-relative item path.
+ * If some components are missing, returns an incomplete reference.
+ */
+function itemPathToItemRefLike(hasSubregisters, itemPath) {
+    var _a;
+    const pathNormalized = itemPath.trim()
+        ? stripLeadingSlash(itemPathNotInCR(itemPath))
+        : undefined;
+    const pathParts = (_a = pathNormalized === null || pathNormalized === void 0 ? void 0 : pathNormalized.split('/')) !== null && _a !== void 0 ? _a : [];
+    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 === null || objPath === void 0 ? void 0 : 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) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = stripLeadingSlash(givenItemPath).match(CR_ITEM_PREFIX_REGEX)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.crID) !== null && _c !== void 0 ? _c : 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,49 @@
+import { itemPathInCR } from './itemPathUtils';
+// TODO: Should it be three path components? Probably four
+export const REGISTER_ITEM_QUERY = `
+  objPath.startsWith("/subregisters/") || (
+    objPath.split("/").length === 3 &&
+    !objPath.startsWith("/proposals/")
+  )
+`;
+/**
+ * Returns a query that matches register item object paths
+ * depending on how they 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(cr.items).
+    //  filter(([, proposal]) => proposal.type === 'clarification' || proposal.type === 'addition').
+    //  map(([itemPath, proposal]) => proposal.type === 'clarification' ? `"${itemPath}"` : `"/proposals/${cr.id}/items/${itemPath}"`);
+    const addedOrClarifiedItemPathsInCR = Object.entries(cr.items).
+        filter(([, proposal]) => proposal.type !== 'amendment').
+        map(([itemPath,]) => `"${itemPathInCR(itemPath, cr.id)}"`);
+    const addedOrClarifiedItemPathsNotInCR = Object.entries(cr.items).
+        filter(([, proposal]) => proposal.type !== 'amendment').
+        map(([itemPath,]) => `"${itemPath}"`);
+    return `
+    ([${addedOrClarifiedItemPathsInCR.join(',')}].indexOf(objPath) >= 0)
+    ||
+    ([${addedOrClarifiedItemPathsNotInCR.join(',')}].indexOf(objPath) < 0 && (${REGISTER_ITEM_QUERY}))
+  `;
+}
+/**
+ * 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;
+    // console.debug("CR QUERY", baseQuery);
+    return `return (${baseQuery}) && (${queryExpression.trim()})`;
+}
+//# sourceMappingURL=itemQueryUtils.js.map

package/compiled/views/protocolRegistry.js

@@ -0,0 +1,30 @@
+import RegisterItem from './detail/RegisterItem';
+import RegisterItemClass from './detail/RegisterItemClass';
+import RegisterMeta from './detail/RegisterMeta';
+import ChangeRequest from './detail/ChangeRequest';
+import CustomView from './detail/CustomView';
+import ProposalWork from './detail/ProposalWork';
+export const Protocols = {
+    ITEM_DETAILS: 'itemdetails',
+    ITEM_CLASS: 'itemclass',
+    PROPOSAL_WORK: 'proposalwork',
+    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.ITEM_CLASS]: RegisterItemClass,
+    [Protocols.REGISTER_META]: RegisterMeta,
+    [Protocols.PROPOSAL_WORK]: ProposalWork,
+    [Protocols.CHANGE_REQUEST]: ChangeRequest,
+    [Protocols.CUSTOM_VIEW]: CustomView,
+};
+export default protocolRegistry;
+//# sourceMappingURL=protocolRegistry.js.map