@riboseinc/paneron-registry-kit 2.2.58 → 2.2.60

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Ribose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.adoc

@@ -0,0 +1,67 @@
+= Paneron registry kit
+
+ifdef::env-github[]
+image:https://github.com/paneron/registry-kit/actions/workflows/tests.yml/badge.svg[
+  "Test Status",
+  link="https://github.com/paneron/registry-kit/actions/workflows/tests.yml"]
+image:https://github.com/paneron/registry-kit/actions/workflows/audit.yml/badge.svg[
+  "Audit Status",
+  link="https://github.com/paneron/registry-kit/actions/workflows/audit.yml"]
+
+image:https://github.com/paneron/registry-kit/actions/workflows/release.yml/badge.svg[
+  "Release Status",
+  link="https://github.com/paneron/registry-kit/actions/workflows/release.yml"]
+
+image:https://img.shields.io/npm/v/%40riboseinc%2Fpaneron-registry-kit[
+  NPM release,
+  link="https://www.npmjs.com/package/@riboseinc/paneron-registry-kit"]
+
+// image:https://img.shields.io/github/v/release/paneron/registry-kit?display_name=tag&include_prereleases&sort=semver[
+//   GitHub release (latest SemVer including pre-releases),
+//   link="https://www.npmjs.com/package/@paneron/registry-kit"
+// ]
+endif::[]
+
+
+A common case of structured data is _registers_, as defined by ISO 19135-1 standard.
+
+Registry kit defines a model for expressing ISO 19135-1 register data as a collection of YAML files,
+and simplifies creating Paneron extensions that work with that data.
+
+
+== Extension development
+
+See
+link:https://github.com/paneron/extension-kit/blob/master/EXTENSION_DEVELOPMENT.adoc[extension kit’s documentation^]
+for general extension development notes.
+
+
+== Extensions for editing registry data
+
+An extension is essentially a React component that is given as props
+some functions that simplify interaction with underlying data repository.
+
+In case of registry type extensions, instead of writing your own repository view component from scratch,
+with registry kit you can import its registry view component
+and pass it a configuration of register item classes that your register supports
+alongside props passed by Paneron to your extension.
+
+The configuration of register item classes includes the following:
+
+- General item metadata
+-- Machine-readable class identifier, which will also serve as the name of the directory item contents reside in
+-- Human-readable item class title, as well as alternative names (if any)
+-- Item class description, as plain string
+- Default values for register item data
+- React components that serve as views of a given register item
+-- Displaying item data
+-- Editing item data
+-- Displaying item in list
+
+For an example of a Paneron extension built with registry kit, see the
+link:https://github.com/paneron/extension-geodetic-registry/[ISO/TC 211 Geodetic registry extension^].
+
+
+==== License
+
+See link:./LICENSE[`LICENSE`^] for license information.

package/compiled/common.js

@@ -0,0 +1,2 @@
+export const REGISTER_METADATA_FILENAME = '/register.yaml';
+//# sourceMappingURL=common.js.map

package/compiled/index.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import { makeExtension } from '@riboseinc/paneron-extension-kit';
+import ErrorBoundary from '@riboseinc/paneron-extension-kit/widgets/ErrorBoundary';
+import datasetInitializer from './migrations/initial';
+import { RegistryView } from './views';
+export const makeRegistryExtension = function (opts) {
+    const { name } = opts;
+    for (const cls of Object.values(opts.itemClassConfiguration)) {
+        for (const [viewID, view] of Object.entries(cls.views)) {
+            const View = view;
+            if (View) {
+                cls.views[viewID] = function WrappedRegisterItemView(props) {
+                    return (React.createElement(ErrorBoundary, { viewName: `Detail view for ${cls.meta.title}`, inline: viewID === 'listItemView' },
+                        React.createElement(View, { ...props })));
+                };
+            }
+        }
+    }
+    const mainView = function _RegistryView() {
+        return (React.createElement(RegistryView, { itemClassConfiguration: opts.itemClassConfiguration, itemClassGroups: opts.itemClassGroups, subregisters: opts.subregisters, CustomWorkspace: opts.CustomWorkspace, defaultSearchCriteria: opts.defaultSearchCriteria, keyExpression: opts.keyExpression, getQuickSearchPredicate: opts.getQuickSearchPredicate, alterApprovedCR: opts.alterApprovedCR }));
+    };
+    return makeExtension({
+        mainView,
+        name,
+        requiredHostAppVersion: '2.0.0',
+        datasetMigrations: {},
+        datasetInitializer,
+    });
+};
+// Re-exports
+import { BrowserCtx } from './views/BrowserCtx';
+import { itemPathInCR, itemPathToItemRef, itemRefToItemPath, incompleteItemRefToItemPathPrefix } from './views/itemPathUtils';
+import GenericRelatedItemView from './views/GenericRelatedItemView';
+import { PropertyDetailView } from './views/util';
+import CRITERIA_CONFIGURATION from './views/FilterCriteria/CRITERIA_CONFIGURATION';
+import useSingleRegisterItemData from './views/hooks/useSingleRegisterItemData';
+import { isAddition } from './proposals/types';
+import { Protocols } from './views/protocolRegistry';
+import { ChangeRequestContext } from './proposals/ChangeRequestContext';
+import RegisterHome from './views/detail/RegisterHome';
+export { itemRefToItemPath, itemPathToItemRef, itemPathInCR, incompleteItemRefToItemPathPrefix, BrowserCtx, CRITERIA_CONFIGURATION, GenericRelatedItemView, PropertyDetailView, useSingleRegisterItemData, isAddition, Protocols, ChangeRequestContext, RegisterHome, };
+//# sourceMappingURL=index.js.map

package/compiled/item-classes/Tree.js

@@ -0,0 +1,61 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { useContext, useMemo, useCallback } from 'react';
+import { jsx } from '@emotion/react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import { ChangeRequestContext, updateCRObjectChangeset } from '../proposals';
+import GenericStatefulTree from '../views/StatefulTree';
+import { BrowserCtx } from '../views/BrowserCtx';
+import { itemRefToItemPath } from '../views/itemPathUtils';
+import { Protocols } from '../views/protocolRegistry';
+import { getMaybeGroupedItemClassesAsTreeNodes } from './treeNodes';
+const ItemClassTree = function () {
+    const { isBusy, performOperation, updateObjects, makeRandomID } = useContext(DatasetContext);
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const { changeRequest: activeCR, canEdit: activeCRIsEditable } = useContext(ChangeRequestContext);
+    const { subregisters, itemClasses, itemClassGroups } = useContext(BrowserCtx);
+    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.PROPOSAL_WORK);
+    }, [activeCR, activeCRIsEditable, subregisters === undefined, updateObjects, makeRandomID]);
+    const handleAdd = useMemo((() => !subregisters && activeCRIsEditable && performOperation
+        ? (clsID) => performOperation('generating new item', createItem)(clsID)
+        : undefined), [createItem, subregisters === undefined, activeCRIsEditable, performOperation]);
+    const getNodes = useCallback(((state) => {
+        var _a;
+        return getMaybeGroupedItemClassesAsTreeNodes(itemClasses, itemClassGroups, {
+            selectedItemID: (_a = state.selectedItemID) !== null && _a !== void 0 ? _a : undefined,
+            expandedGroupLabels: new Set(state.expandedItemIDs),
+            onProposeItem: !isBusy ? handleAdd : undefined,
+        });
+    }), [isBusy, itemClasses, itemClassGroups, handleAdd]);
+    return jsx(GenericStatefulTree, { getNodes: getNodes, stateKey: "item-browser", onItemDoubleClick: (node) => spawnTab(`${Protocols.ITEM_CLASS}:${node.id}`) });
+};
+export default ItemClassTree;
+//# sourceMappingURL=Tree.js.map

package/compiled/item-classes/treeNodes.js

@@ -0,0 +1,56 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+/**
+ * Tools for rendering proposal groups as tree nodes.
+ * Each proposal group is top-level node, with proposals as nested nodes.
+ */
+//import React, { useContext, useMemo } from 'react';
+import { jsx } from '@emotion/react';
+import { MoreMenu, ItemClassMenu } from '../views/util';
+export function getMaybeGroupedItemClassesAsTreeNodes(itemClasses, itemClassGroups, opts) {
+    if (!itemClassGroups) {
+        return getItemClassesAsTreeNodes(itemClasses, Object.keys(itemClasses), opts);
+    }
+    else {
+        return Object.entries(itemClassGroups).map(([groupLabel, clsIDs]) => {
+            var _a;
+            const hasSelectedClass = (opts === null || opts === void 0 ? void 0 : opts.selectedItemID) && clsIDs.includes(opts.selectedItemID);
+            const isSelected = (opts === null || opts === void 0 ? void 0 : opts.selectedItemID) && groupLabel === opts.selectedItemID
+                ? true
+                : false;
+            const isExpanded = hasSelectedClass || ((_a = opts === null || opts === void 0 ? void 0 : opts.expandedGroupLabels) === null || _a === void 0 ? void 0 : _a.has(groupLabel));
+            return {
+                id: groupLabel,
+                label: groupLabel,
+                hasCaret: true,
+                isSelected,
+                isExpanded,
+                icon: isExpanded ? 'folder-open' : 'folder-close',
+                childNodes: isExpanded
+                    ? getItemClassesAsTreeNodes(itemClasses, clsIDs, opts)
+                    : [],
+                nodeData: { type: 'group' },
+            };
+        });
+    }
+}
+function getItemClassesAsTreeNodes(itemClasses, 
+/** Used for ordering. */
+classIDs, opts) {
+    return classIDs.map(clsID => {
+        var _a;
+        const cls = itemClasses[clsID];
+        return {
+            id: clsID,
+            label: (_a = cls === null || cls === void 0 ? void 0 : cls.meta.title) !== null && _a !== void 0 ? _a : 'unknown class',
+            icon: 'folder-close',
+            isSelected: (opts === null || opts === void 0 ? void 0 : opts.selectedItemID) === clsID,
+            nodeData: { type: 'item' },
+            secondaryLabel: jsx(MoreMenu, null,
+                jsx(ItemClassMenu, { cfg: cls, onCreate: (opts === null || opts === void 0 ? void 0 : opts.onProposeItem) ?
+                        () => opts.onProposeItem(clsID)
+                        : undefined })),
+        };
+    });
+}
+//# sourceMappingURL=treeNodes.js.map

package/compiled/migrations/initial.js

@@ -0,0 +1,28 @@
+import { REGISTER_METADATA_FILENAME } from '../common';
+const enc = new TextEncoder();
+const metadata = enc.encode(`
+name: Unnamed registry
+stakeholders:
+  - role: submitter
+    name: owner entity name here...
+    gitServerUsername: VCS username here...
+    parties:
+      - name: owner entity party name here...
+        contacts:
+          - label: email
+            value: owner entity party contact email here...
+version:
+  id: '1'
+  timestamp: ${(new Date()).toISOString()}
+contentSummary: content summary goes here...
+`);
+const initialMigration = {
+    versionAfter: '1.0.0',
+    migrator: async function* initialRegistryMigration() {
+        yield {
+            [REGISTER_METADATA_FILENAME]: metadata,
+        };
+    },
+};
+export default initialMigration;
+//# sourceMappingURL=initial.js.map

package/compiled/proposals/ChangeRequestContext.js

@@ -0,0 +1,121 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import React, { useMemo, useContext } from 'react';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { isRegisterItem } from '../types';
+import { BrowserCtx } from '../views/BrowserCtx';
+import { itemRefToItemPath, crIDToCRPath } from '../views/itemPathUtils';
+import { canBeTransitionedBy } from './TransitionOptions';
+import { updateCRObjectChangeset } from './objectChangeset';
+import { canBeDeletedBy, canBeEditedBy } from './types';
+export const ChangeRequestContext = React.createContext({
+    changeRequest: null,
+    canEdit: false,
+    canTransition: false,
+    canDelete: false,
+});
+export const ChangeRequestContextProvider = function ({ changeRequestID, children }) {
+    var _a, _b;
+    const { useObjectData, makeRandomID, updateObjects, updateTree, performOperation, isBusy } = useContext(DatasetContext);
+    const { itemClasses, subregisters, stakeholder } = useContext(BrowserCtx);
+    const crPath = changeRequestID ? crIDToCRPath(changeRequestID) : null;
+    const changeRequest = (_b = (_a = useObjectData({
+        objectPaths: crPath ? [crPath] : [],
+        nounLabel: 'proposal(s)',
+    }).value) === null || _a === void 0 ? void 0 : _a.data[crPath !== null && crPath !== void 0 ? crPath : '']) !== null && _b !== void 0 ? _b : (crPath ? undefined : null);
+    const canEdit = changeRequest
+        && stakeholder
+        && canBeEditedBy(stakeholder, changeRequest)
+        ? true
+        : false;
+    const canTransition = changeRequest
+        && stakeholder
+        && canBeTransitionedBy(stakeholder, changeRequest)
+        ? true
+        : false;
+    const canDelete = changeRequest
+        && stakeholder
+        && canBeDeletedBy(stakeholder, changeRequest)
+        ? true
+        : false;
+    const deleteCR = useMemo((() => !isBusy && canDelete && updateTree
+        ? performOperation('deleting proposal', async function handleDelete() {
+            const subtreeRoot = crIDToCRPath(changeRequest.id).replace('/main.yaml', '');
+            await updateTree({
+                subtreeRoot,
+                newSubtreeRoot: null,
+                commitMessage: 'remove unproposed CR draft',
+            });
+        })
+        : undefined), [
+        isBusy, performOperation,
+        updateTree,
+        canDelete,
+    ]);
+    const proposeBlankItem = useMemo((() => {
+        if (!updateObjects || !makeRandomID || !canEdit || !changeRequest) {
+            return undefined;
+        }
+        else {
+            return performOperation('creating blank item', async function _createItem(classID, subregisterID) {
+                var _a;
+                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(changeRequest, { [itemPath]: { type: 'addition' } }, { [itemPath]: registerItem }),
+                    _dangerouslySkipValidation: true,
+                });
+                return ref;
+            });
+        }
+    }), [changeRequest, canEdit, subregisters === undefined, updateObjects, makeRandomID]);
+    const updateItemProposal = useMemo((() => changeRequest && canEdit && updateObjects
+        ? async function _handleSetProposal(summary, proposal, itemPath, item, editedItemData) {
+            if (proposal && !item) {
+                throw new Error("Missing item");
+            }
+            if (proposal && (proposal === null || proposal === void 0 ? void 0 : proposal.type) !== 'amendment' && (!editedItemData || !isRegisterItem(editedItemData))) {
+                throw new Error("Missing item data");
+            }
+            await updateObjects({
+                commitMessage: `${summary} for ${itemPath}`,
+                objectChangeset: updateCRObjectChangeset(
+                // TODO: We are sure it’s editable already, but casting should be avoided
+                changeRequest, { [itemPath]: proposal }, ((proposal && (proposal === null || proposal === void 0 ? void 0 : proposal.type) !== 'amendment') && editedItemData && item)
+                    ? { [itemPath]: { ...item, data: editedItemData } }
+                    : {}),
+                // We need this because updateCRObjectChangeset
+                // omits oldValue for item data payloads.
+                _dangerouslySkipValidation: true,
+            });
+        }
+        : undefined), [canEdit, changeRequest, updateObjects]);
+    const ctx = useMemo((() => ({
+        changeRequest,
+        canEdit,
+        canTransition,
+        canDelete,
+        deleteCR,
+        proposeBlankItem,
+        updateItemProposal,
+    })), [changeRequest, canEdit, deleteCR, canDelete, proposeBlankItem, updateItemProposal]);
+    return (jsx(ChangeRequestContext.Provider, { value: ctx }, children));
+};
+//# sourceMappingURL=ChangeRequestContext.js.map

package/compiled/proposals/HistoryDrawer.js

@@ -0,0 +1,55 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import { jsx } from '@emotion/react';
+import React, { useCallback, useContext, useMemo, useState } from 'react';
+import { Drawer } from '@blueprintjs/core';
+import { TabbedWorkspaceContext } from '@riboseinc/paneron-extension-kit/widgets/TabbedWorkspace/context';
+import makeSearchResultList from '@riboseinc/paneron-extension-kit/widgets/SearchResultList';
+import { State, hasSubmitterInput, isDisposed, hadBeenProposed } from '../proposals/types';
+import { isProposal } from '../proposals/types';
+import { ProposalType } from './ProposalType';
+import { Datestamp } from '../views/util';
+import { DISPOSED_CR_QUERY } from './queries';
+import { Protocols } from '../views/protocolRegistry';
+/** History of changes affecting given item. */
+const ProposalHistoryDrawer = function ({ itemPath, isOpen, onClose, }) {
+    const { spawnTab } = useContext(TabbedWorkspaceContext);
+    const [selectedItemPath, setSelectedItemPath] = useState(null);
+    // Return disposed CRs
+    // that were either accepted or accepted on appeal
+    // and have the item in question.
+    const query = `return (
+    (${DISPOSED_CR_QUERY})
+    && (obj.state === "${State.ACCEPTED}" || obj.state === "${State.ACCEPTED_ON_APPEAL}")
+    && obj.items["${itemPath}"] !== undefined
+  )`;
+    return (jsx(Drawer, { isOpen: isOpen, onClose: onClose, enforceFocus: false, size: "50vw", style: { padding: '0', width: 'unset' } },
+        jsx(ProposalList, { queryExpression: query, keyExpression: "(new Date()).getTime() * 100 - (typeof obj.timeDisposed === 'object' ? (obj.timeDisposed ?? new Date()) : new Date(obj.timeDisposed)).getTime() + Math.floor(Math.random() * 1000)", selectedItemPath: selectedItemPath, onSelectItem: setSelectedItemPath, onOpenItem: useCallback((itemPath => spawnTab(`${Protocols.CHANGE_REQUEST}:${itemPath}`)), [spawnTab]), extraItemViewData: useMemo(() => ({ itemPath }), [itemPath]) })));
+};
+const ProposalHistoryItem = function ({ objectData, extraData }) {
+    const justification = hasSubmitterInput(objectData) ? objectData.justification : 'N/A';
+    const change_ = (extraData === null || extraData === void 0 ? void 0 : extraData.itemPath) ? objectData.items[extraData === null || extraData === void 0 ? void 0 : extraData.itemPath] : undefined;
+    const change = isProposal(change_) ? change_ : null;
+    return jsx("span", { title: `Accepted proposal “${justification}” (proposal ID: ${objectData.id})` },
+        change ? jsx(ProposalType, { proposal: change }) : null,
+        isDisposed(objectData)
+            ? jsx(React.Fragment, null,
+                jsx(Datestamp, { date: objectData.timeDisposed, title: "Disposed" }),
+                ": ")
+            : hadBeenProposed(objectData)
+                ? jsx(React.Fragment, null,
+                    jsx(Datestamp, { date: objectData.timeProposed, title: "Proposed" }),
+                    ": ")
+                : null,
+        justification);
+};
+const ProposalList = makeSearchResultList(ProposalHistoryItem, (objPath) => ({
+    name: 'Prp.',
+    iconProps: {
+        icon: 'lightbulb',
+        title: objPath,
+        htmlTitle: `icon for proposal at ${objPath}`,
+    },
+}));
+export default ProposalHistoryDrawer;
+//# sourceMappingURL=HistoryDrawer.js.map

package/compiled/proposals/ListItem.js

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { Datestamp } from '../views/util';
+import { isDisposed, hadBeenProposed, hasSubmitterInput } from './types';
+export const ProposalAsListItem = function ({ proposal, showTime }) {
+    const justification = hasSubmitterInput(proposal) ? proposal.justification : 'N/A';
+    return jsx("span", { title: `${justification} (proposal ID: ${proposal.id})` },
+        isDisposed(proposal)
+            ? jsx(React.Fragment, null,
+                jsx(Datestamp, { useUTC: true, showTimeIfNonZero: showTime, date: proposal.timeDisposed, title: "Disposed" }),
+                ": ")
+            : hadBeenProposed(proposal)
+                ? jsx(React.Fragment, null,
+                    jsx(Datestamp, { useUTC: true, showTimeIfNonZero: showTime, date: proposal.timeProposed, title: "Proposed" }),
+                    ": ")
+                : null,
+        justification);
+};
+export default ProposalAsListItem;
+//# sourceMappingURL=ListItem.js.map

package/compiled/proposals/MetaProperties.js

@@ -0,0 +1,98 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useContext, useMemo } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Tag } from '@blueprintjs/core';
+import HelpTooltip from '@riboseinc/paneron-extension-kit/widgets/HelpTooltip';
+import { DatasetContext } from '@riboseinc/paneron-extension-kit/context';
+import { RegisterStakeholderListItem } from '../views/RegisterStakeholder';
+import { crIDToCRPath } from '../views/itemPathUtils';
+import useLatestAcceptedProposal from '../views/hooks/useLatestAcceptedProposal';
+import ProposalAsListItem from './ListItem';
+import { hasSubmitterInput, isCreatedBy } from './types';
+/** Proposal meta properties, must be nested within a DL. */
+const Summary = function ({ cr, currentStakeholder, register, compareRegisterVersion }) {
+    var _a, _b, _c, _d, _e;
+    const { useObjectData } = useContext(DatasetContext);
+    const crPath = crIDToCRPath(cr.registerVersion);
+    const previousProposal = (_b = (_a = useObjectData({
+        objectPaths: crPath ? [crPath] : [],
+        nounLabel: 'proposal(s)',
+    }).value) === null || _a === void 0 ? void 0 : _a.data[crPath !== null && crPath !== void 0 ? crPath : '']) !== null && _b !== void 0 ? _b : (crPath ? undefined : null);
+    const registerVersion = previousProposal && hasSubmitterInput(previousProposal)
+        ? jsx(ProposalAsListItem, { showTime: true, proposal: previousProposal })
+        : (_c = cr.registerVersion) !== null && _c !== void 0 ? _c : 'N/A';
+    let currentVersion;
+    try {
+        currentVersion = (_e = (_d = useLatestAcceptedProposal()) === null || _d === void 0 ? void 0 : _d.id) !== null && _e !== void 0 ? _e : undefined;
+    }
+    catch (e) {
+        console.error("Failed to obtain latest accepted proposal");
+        currentVersion = undefined;
+    }
+    const submittingStakeholder = useMemo((() => { var _a; return ((_a = register === null || register === void 0 ? void 0 : register.stakeholders) !== null && _a !== void 0 ? _a : []).find(s => isCreatedBy(s, cr)); }), [register, cr]);
+    const isCurrentMarker = useMemo(() => {
+        const proposedAgainstCurrentVersion = cr.registerVersion === currentVersion;
+        const shouldShowMarker = compareRegisterVersion && cr.registerVersion;
+        const marker = shouldShowMarker
+            ? jsx(Tag, { css: css `display: inline;`, intent: currentVersion
+                    ? proposedAgainstCurrentVersion
+                        ? 'success'
+                        : 'warning'
+                    : undefined, minimal: true, round: true }, currentVersion
+                ? proposedAgainstCurrentVersion
+                    ? jsx(React.Fragment, null,
+                        "current",
+                        " ",
+                        jsx(HelpTooltip, { intent: 'success', content: jsx(React.Fragment, null,
+                                "Published version of the register",
+                                " ",
+                                "had not changed since this proposal started.") }))
+                    : jsx(React.Fragment, null,
+                        "not current",
+                        " ",
+                        jsx(HelpTooltip, { intent: 'warning', icon: 'warning-sign', content: jsx(React.Fragment, null,
+                                "Register is currently at version ",
+                                jsx("strong", null, currentVersion),
+                                ",",
+                                " ",
+                                "which is different from version proposal author may have had in mind.",
+                                " ",
+                                "It is recommended that proposed changes are reviewed to avoid unintentionally",
+                                " ",
+                                "undoing a prior change.") }))
+                : jsx(React.Fragment, null,
+                    "unable to compare",
+                    " ",
+                    jsx(HelpTooltip, { intent: undefined, icon: 'warning-sign', content: jsx(React.Fragment, null,
+                            "Unable to determine current register version.",
+                            " ",
+                            "This may be the case if there are no accepted proposals (since register version is derived from latest accepted proposal).",
+                            " ",
+                            "Barring that, there may be a data integrity issue.") })))
+            : null;
+        return marker ? jsx(React.Fragment, null,
+            "\u2002",
+            marker) : null;
+    }, [cr.registerVersion, currentVersion, compareRegisterVersion]);
+    return (jsx(React.Fragment, null,
+        submittingStakeholder
+            ? jsx("div", null,
+                jsx("dt", null, "Author:"),
+                jsx("dd", null,
+                    jsx(RegisterStakeholderListItem, { stakeholder: submittingStakeholder, showRole: true, isCurrentUser: (currentStakeholder
+                            ? isCreatedBy(currentStakeholder, cr)
+                            : false) || undefined })))
+            : null,
+        jsx("div", null,
+            jsx("dt", null, "Register\u00A0version before\u00A0proposal:"),
+            jsx("dd", null,
+                registerVersion,
+                isCurrentMarker)),
+        jsx("div", null,
+            jsx("dt", null, "Proposal\u00A0ID:"),
+            jsx("dd", null,
+                jsx("code", { css: css `white-space: nowrap;` }, cr.id)))));
+};
+export default Summary;
+//# sourceMappingURL=MetaProperties.js.map

package/compiled/proposals/NewProposalMenu.js

@@ -0,0 +1,53 @@
+/** @jsx jsx */
+/** @jsxFrag React.Fragment */
+import React, { useState, useCallback, useMemo, } from 'react';
+import { jsx, css } from '@emotion/react';
+import { Button, FormGroup, ControlGroup, TextArea, PanelStack2 as PanelStack, Menu, MenuItem, NonIdealState, } from '@blueprintjs/core';
+const NewProposalMenu = function ({ previousVersion, onCreateBlank, onImport, className }) {
+    const [createMode, setCreateMode] = useState(false);
+    const creatingBlank = onCreateBlank && createMode;
+    const stack = useMemo(() => {
+        const stack = [];
+        const createMenu = (jsx(Menu, { css: css `overflow-y: auto; background: none !important;` },
+            jsx(MenuItem, { text: "Start a proposal from scratch", onClick: (onCreateBlank && !createMode)
+                    ? (() => setCreateMode(true))
+                    : undefined, disabled: !onCreateBlank, active: creatingBlank, selected: creatingBlank, icon: "add" }),
+            jsx(MenuItem, { text: "Import a pre-existing proposal", onClick: onImport, disabled: !onImport || creatingBlank, icon: "import" })));
+        stack.push({
+            title: "Start new proposal",
+            renderPanel: () => createMenu,
+        });
+        if (creatingBlank) {
+            stack.push({
+                title: "Start a proposal from scratch",
+                renderPanel: () => jsx(NewProposal, { previousVersion: previousVersion, onCreateBlank: onCreateBlank, css: css `padding: 5px;` }),
+            });
+        }
+        return stack;
+    }, [onCreateBlank, onImport, creatingBlank, previousVersion]);
+    return jsx(PanelStack, { css: css `flex: 1; overflow: unset; .bp4-panel-stack-view { background: none; border: none; }`, className: className, onClose: () => setCreateMode(false), stack: stack.length > 0
+            ? stack
+            : [{ title: '', renderPanel: () => jsx(NonIdealState, { title: "Nothing to show" }) }] });
+};
+export default NewProposalMenu;
+const NewProposal = function ({ previousVersion, onCreateBlank, className }) {
+    const [newProposalIdea, setNewProposalIdea] = useState('');
+    const handleNewProposal = useCallback(async function handleNewProposal() {
+        if (newProposalIdea.trim()) {
+            await (onCreateBlank === null || onCreateBlank === void 0 ? void 0 : onCreateBlank(newProposalIdea));
+            setNewProposalIdea('');
+        }
+        else {
+            throw new Error("Cannot create proposal: need some initial motivation for the change");
+        }
+    }, [newProposalIdea, onCreateBlank]);
+    return (jsx(FormGroup, { className: className, css: css `overflow-y: auto;`, label: jsx(React.Fragment, null,
+            "Propose",
+            previousVersion
+                ? ` a change to version ${previousVersion}:`
+                : ` the first change:`) },
+        jsx(ControlGroup, { vertical: true },
+            jsx(TextArea, { value: newProposalIdea !== null && newProposalIdea !== void 0 ? newProposalIdea : '', placeholder: "Your idea\u2026", title: "Justification draft (you can change this later)", onChange: evt => setNewProposalIdea(evt.currentTarget.value) }),
+            jsx(Button, { fill: true, intent: newProposalIdea ? 'primary' : undefined, disabled: !newProposalIdea.trim() || !onCreateBlank, title: "A blank proposal will be created and opened in a new tab.", onClick: handleNewProposal, icon: "tick" }, "Create"))));
+};
+//# sourceMappingURL=NewProposalMenu.js.map