@riboseinc/paneron-registry-kit 2.2.59 → 2.2.60

package/compiled/proposals/actionableGroups/treeNodes.js

@@ -0,0 +1,90 @@
+/** @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 { useCallback } from 'react';
+import { jsx } from '@emotion/react';
+import { Button, Tag } from '@blueprintjs/core';
+import { CR_BASE_QUERY } from '../queries';
+export function getActionableProposalGroupsAsTreeNodes(groups, opts) {
+    return groups.
+        //filter(({ proposals }) => proposals && proposals.length > 0).
+        map(({ groupLabel, proposals }) => {
+        var _a;
+        const hasProposals = proposals && proposals.length > 0;
+        const hasActiveProposal = hasProposals
+            && (opts === null || opts === void 0 ? void 0 : opts.activeCRID) && proposals.find(p => p.id === opts.activeCRID);
+        const hasSelectedProposal = hasProposals
+            && (opts === null || opts === void 0 ? void 0 : opts.selectedCRID) && proposals.find(p => p.id === opts.selectedCRID);
+        const isExpanded = groups.length === 1
+            || ((_a = opts === null || opts === void 0 ? void 0 : opts.expandedGroupLabels) === null || _a === void 0 ? void 0 : _a.has(groupLabel))
+            || hasSelectedProposal
+            ? true
+            : false;
+        return {
+            id: groupLabel,
+            label: groupLabel,
+            hasCaret: true,
+            className: hasActiveProposal
+                ? 'tree-node-proposal-group-with-active-proposal'
+                : undefined,
+            secondaryLabel: hasActiveProposal && !isExpanded
+                ? jsx(ActiveMarker, { isActive: true, title: "A proposal in this group is currently active, expand group to see it" })
+                : jsx(Tag, { minimal: !hasProposals, intent: hasProposals ? 'warning' : undefined }, hasProposals ? proposals.length : 0),
+            icon: isExpanded
+                ? 'folder-open'
+                : 'folder-close',
+            isExpanded,
+            isSelected: groupLabel === (opts === null || opts === void 0 ? void 0 : opts.selectedGroup),
+            nodeData: { type: 'group' },
+            childNodes: hasProposals && isExpanded
+                ? proposals.map(p => getActionableProposalTreeNode(p, {
+                    isSelected: p.id === (opts === null || opts === void 0 ? void 0 : opts.selectedCRID),
+                    isActive: p.id === (opts === null || opts === void 0 ? void 0 : opts.activeCRID),
+                    onActivateCR: opts === null || opts === void 0 ? void 0 : opts.onActivateCR,
+                }))
+                : [],
+        };
+    });
+}
+const ActiveMarker = function ({ onToggle, title, isActive }) {
+    const handleClick = useCallback(((evt) => {
+        evt.stopPropagation();
+        onToggle === null || onToggle === void 0 ? void 0 : onToggle();
+    }), [onToggle]);
+    return jsx(Button, { icon: "eye-open", small: true, title: title !== null && title !== void 0 ? title : (onToggle
+            ? isActive
+                ? "Click to deactivate (exit) this proposal"
+                : "Click to activate this proposal"
+            : undefined), active: isActive, intent: isActive ? 'danger' : 'primary', disabled: !onToggle, onClick: handleClick });
+};
+function getActionableProposalTreeNode(proposal, opts) {
+    var _a;
+    return {
+        id: proposal.id,
+        label: jsx("span", { title: `“${proposal.justification}” — double-click to open & activate this proposal` }, proposal.justification),
+        isSelected: (_a = opts === null || opts === void 0 ? void 0 : opts.isSelected) !== null && _a !== void 0 ? _a : false,
+        icon: 'lightbulb',
+        className: (opts === null || opts === void 0 ? void 0 : opts.isActive)
+            ? 'tree-node-active-proposal'
+            : undefined,
+        secondaryLabel: (opts === null || opts === void 0 ? void 0 : opts.isActive)
+            ? jsx(ActiveMarker, { isActive: true, onToggle: opts.onActivateCR ? () => { var _a; return (_a = opts === null || opts === void 0 ? void 0 : opts.onActivateCR) === null || _a === void 0 ? void 0 : _a.call(opts, null); } : undefined })
+            : jsx(ActiveMarker, { onToggle: (opts === null || opts === void 0 ? void 0 : opts.onActivateCR) ? () => { var _a; return (_a = opts === null || opts === void 0 ? void 0 : opts.onActivateCR) === null || _a === void 0 ? void 0 : _a.call(opts, proposal.id); } : undefined }),
+        nodeData: { type: 'item' },
+    };
+}
+export function getMapReduceChainsForActionableProposalGroups(proposalGroups, stakeholder) {
+    return proposalGroups.map(([label, , queryGetter]) => {
+        const query = queryGetter(stakeholder);
+        const predicateFunc = `
+      const objPath = key, obj = value;
+      return ((${CR_BASE_QUERY}) && (${query}));
+    `;
+        const mapFunc = `emit(value);`;
+        return { [label]: { mapFunc, predicateFunc } };
+    }).reduce((prev, curr) => ({ ...prev, ...curr }), {});
+}
+//# sourceMappingURL=treeNodes.js.map

package/compiled/proposals/actionableGroups/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/compiled/proposals/index.js

@@ -0,0 +1,7 @@
+export * from './ChangeRequestContext';
+export * from './objectChangeset';
+export * from './types';
+export * from './ProposalBrowser';
+export * from './queries';
+export * from './actionableGroups/queries';
+//# sourceMappingURL=index.js.map

package/compiled/proposals/objectChangeset.js

@@ -0,0 +1,331 @@
+import { crIDToCRPath, itemPathInCR, itemPathToItemRef, itemRefToItemPath, } from '../views/itemPathUtils';
+import { isRegisterItem } from '../types';
+import { State, } from './types';
+/** Takes a justification and ID, returns an object changeset. */
+export function newCRObjectChangeset(id, justification, registerVersion, stakeholderGitServerUsername) {
+    const timeStarted = new Date();
+    const cr = {
+        id,
+        timeStarted,
+        timeEdited: timeStarted,
+        justification,
+        submittingStakeholderGitServerUsername: stakeholderGitServerUsername,
+        items: {},
+        state: State.DRAFT,
+        registerVersion,
+    };
+    const crObjectPath = crIDToCRPath(id);
+    return {
+        [crObjectPath]: {
+            oldValue: null,
+            newValue: cr,
+        },
+    };
+}
+/**
+ * Returns an object changeset given an importable proposal,
+ * item class definitions for register to import it to,
+ * and a function to fetch register item data.
+ *
+ * Throws an error if importable proposal data isn’t compatible
+ * with item class definitions or existing register data.
+ */
+export async function importedProposalToCRObjectChangeset(importableCR, 
+/** Available item classes per register configuration. */
+itemClasses, 
+/** VCS username of the person performing the import. */
+importingStakeholderGitServerUsername, getObjectData, resolvePredicates) {
+    var _a;
+    const proposalDraft = importableCR.proposalDraft;
+    proposalDraft.submittingStakeholderGitServerUsername = importingStakeholderGitServerUsername;
+    const crID = proposalDraft.id;
+    const crPath = crIDToCRPath(crID);
+    const itemPaths = Object.keys(proposalDraft.items);
+    for (const itemPath of itemPaths) {
+        const itemRef = itemPathToItemRef(false, itemPath);
+        if (!itemClasses[itemRef.classID]) {
+            throw new Error(`Imported proposal contains item(s) of unknown class ${itemRef.classID}`);
+        }
+    }
+    //const proposals = Object.values(proposalDraft.items);
+    // if (proposals.find(prop => prop.type !== 'addition')) {
+    //   throw new Error("Only addition proposals can be imported at this time");
+    // }
+    const additionalItemPaths = Object.entries(proposalDraft.items).
+        filter(([, prop]) => prop.type === 'addition').
+        map(([path,]) => path);
+    const existingItems = (await getObjectData({ objectPaths: additionalItemPaths })).data;
+    if (Object.values(existingItems).find(v => v !== null)) {
+        throw new Error("Register already contains item(s) being added in this proposal");
+    }
+    const clarifiedItemPaths = Object.entries(proposalDraft.items).
+        filter(([, prop]) => prop.type === 'clarification').
+        map(([path,]) => path);
+    const clarifiedItems = (await getObjectData({ objectPaths: clarifiedItemPaths })).data;
+    if (Object.values(clarifiedItems).find(v => v === null)) {
+        throw new Error("Register does not contain some of the item(s) being clarified in this proposal");
+    }
+    const changeset = {
+        [crPath]: {
+            oldValue: null,
+            newValue: proposalDraft,
+        },
+    };
+    for (const [itemPath, itemPayload] of Object.entries((_a = importableCR.itemPayloads) !== null && _a !== void 0 ? _a : {})) {
+        if (itemPaths.indexOf(itemPath) < 0) {
+            throw new Error(`No proposal found for item at ${itemPath}, but item data is given`);
+        }
+        if (!isRegisterItem(itemPayload)) {
+            throw new Error(`Invalid register item data at ${itemPath}`);
+        }
+        const predicates = collectPredicates(itemPayload);
+        if (predicates.size < 1) {
+            changeset[itemPathInCR(itemPath, crID)] = {
+                oldValue: null,
+                newValue: itemPayload,
+            };
+        }
+        else {
+            if (!resolvePredicates) {
+                throw new Error("Cannot resolve some predicates in imported proposal");
+            }
+            changeset[itemPathInCR(itemPath, crID)] = {
+                oldValue: null,
+                newValue: replacePredicates(itemPayload, await resolvePredicates(predicates)),
+            };
+        }
+    }
+    return [changeset, crID];
+}
+function isPredicate(val) {
+    return val && val.__isPredicate === true;
+}
+/**
+ * Resolves any properties that should reference register item UUIDs,
+ * but have predicates instead, using a map of found predicates
+ * and item references they already were resolved to.
+ */
+function replacePredicates(value, resolvedPredicates) {
+    // NOTE: Return types are cast because https://github.com/microsoft/TypeScript/issues/33912.
+    if (isPredicate(value)) {
+        const ref = resolvedPredicates[value.predicate];
+        if (!ref) {
+            throw new Error(`Could not resolve predicate “${value.predicate}”`);
+        }
+        if (value.mode === 'generic') {
+            return ref;
+        }
+        else {
+            return ref.itemID;
+        }
+    }
+    else if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+            return value.map((v) => replacePredicates(v, resolvedPredicates));
+        }
+        else {
+            // Assume plain non-array object.
+            for (const [key, v] of Object.entries(value)) {
+                value[key] = replacePredicates(v, resolvedPredicates);
+            }
+            return value;
+        }
+    }
+    else {
+        return value;
+    }
+}
+function collectPredicates(
+/**
+ * Imported register item data with possibly some predicates
+ * instead of related item references.
+ */
+value, 
+/** Cache for recursive calls, don’t supply. */
+_cache) {
+    const collected = _cache !== null && _cache !== void 0 ? _cache : new Set();
+    if (isPredicate(value)) {
+        collected.add(value.predicate);
+    }
+    else if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+            for (const item in value) {
+                collectPredicates(item, collected);
+            }
+            value.map((v) => collectPredicates(v, collected));
+        }
+        else {
+            // Assume plain non-array object.
+            for (const v of Object.values(value)) {
+                collectPredicates(v, collected);
+            }
+        }
+    }
+    return collected;
+}
+/**
+ * Returns an object changeset to update CR with new given proposal items.
+ * Only applicable to CR at draft edit stage.
+ */
+export function updateCRObjectChangeset(
+/**
+ * Change request data.
+ */
+cr, 
+/**
+ * Proposals by item path.
+ * Will be merged with those already existing in `cr`.
+ * If a proposal is undefined, it will be removed.
+ */
+proposalItems, 
+/**
+ * New item data must be provided for additions and clarifications,
+ * keyed by item path.
+ */
+itemData = {}) {
+    const changeset = {};
+    const newItems = { ...cr.items };
+    for (const [itemPath, proposal] of Object.entries(proposalItems)) {
+        // Update proposals on CR
+        if (proposal !== null) {
+            newItems[itemPath] = proposal;
+        }
+        else if (newItems[itemPath]) {
+            delete newItems[itemPath];
+        }
+        // Add/remove item data
+        if ((proposal === null || proposal === void 0 ? void 0 : proposal.type) === 'addition' || (proposal === null || proposal === void 0 ? void 0 : proposal.type) === 'clarification') {
+            const proposedItemData = itemData[itemPath];
+            if (proposedItemData === null || !isRegisterItem(proposedItemData)) {
+                console.error("Unable to convert proposals to object changeset: original item data is missing", itemPath);
+                throw new Error("Unable to convert proposals to object changeset: original item data is missing");
+            }
+            changeset[itemPathInCR(itemPath, cr.id)] = {
+                // When editing a draft, we don’t care
+                // about overwriting proposed item data so we omit oldValue.
+                newValue: proposedItemData,
+            };
+        }
+        else {
+            changeset[itemPathInCR(itemPath, cr.id)] = {
+                // When editing a draft, we don’t care
+                // about overwriting proposed item data so we omit oldValue.
+                newValue: null,
+            };
+        }
+    }
+    // Update main CR data
+    const crPath = crIDToCRPath(cr.id);
+    changeset[crPath] = {
+        oldValue: cr,
+        newValue: { ...cr, items: newItems, timeEdited: new Date() },
+    };
+    return changeset;
+}
+/**
+ * Given change proposals, returns applicable changes
+ * to objects in the dataset.
+ */
+export async function proposalsToObjectChangeset(crID, hasSubregisters, proposals, itemData, newItemData) {
+    const cs = {};
+    for (const [itemPath, proposal] of Object.entries(proposals)) {
+        //const originalItem: RegisterItem<any> | undefined = (itemData[itemPath] ?? undefined);
+        const itemRef = itemPathToItemRef(hasSubregisters, itemPath);
+        if (proposal.type !== 'addition') {
+            if (itemData[itemPath] === undefined) {
+                console.error("Unable to convert proposals to object changeset: original item data is missing", itemPath);
+                throw new Error("Unable to convert proposals to object changeset: original item data is missing");
+            }
+            if (proposal.type === 'amendment' && proposal.amendmentType === 'supersession') {
+                Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+            }
+            else {
+                Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+            }
+        }
+        else {
+            Object.assign(cs, await proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData));
+        }
+    }
+    return cs;
+}
+// TODO: Refactor out the business logic of proposal approval.
+/**
+ * Given a change proposal, returns applicable changes
+ * to objects in the dataset.
+ * Core logic of approving a proposal.
+ * Takes a proposal and extra options (depending on proposal type).
+ * Returns a Changeset containing register items at appropriate paths.
+ */
+async function proposalToObjectChangeset(crID, proposal, itemRef, itemPath, itemData, newItemData) {
+    var _a, _b, _c;
+    let updatedItem;
+    const changeset = {};
+    const origItem = (_a = itemData[itemPath]) !== null && _a !== void 0 ? _a : null;
+    const newItem = (_b = newItemData[itemPathInCR(itemPath, crID)]) !== null && _b !== void 0 ? _b : null;
+    if (proposal.type !== 'addition') {
+        if (origItem === null) {
+            throw new Error("proposalToObjectChangeset() requires original item data for non-additions");
+        }
+        updatedItem = { ...origItem };
+        switch (proposal.type) {
+            case 'clarification':
+                if (newItem === null) {
+                    throw new Error("proposalToObjectChangeset() requires new item data for clarifications");
+                }
+                //const clarification = proposal as Clarification;
+                updatedItem.data = newItem.data; //clarification.payload;
+                break;
+            case 'amendment':
+                const amendment = proposal;
+                updatedItem.amendedInCR = crID;
+                switch (amendment.amendmentType) {
+                    case 'retirement':
+                        updatedItem.status = 'retired';
+                        break;
+                    case 'invalidation':
+                        updatedItem.status = 'invalid';
+                        break;
+                    case 'supersession':
+                        const supersession = proposal;
+                        updatedItem.status = 'superseded';
+                        updatedItem.supersededBy = supersession.supersedingItemIDs.map(itemID => ({
+                            itemID,
+                            classID: itemRef.classID,
+                            subregisterID: itemRef.subregisterID,
+                        }));
+                        for (const supersedingItemPath of updatedItem.supersededBy.map(ip => itemRefToItemPath(ip))) {
+                            const supersedingItemData = itemData[supersedingItemPath];
+                            if (supersedingItemData) {
+                                changeset[supersedingItemPath] = {
+                                    oldValue: supersedingItemData,
+                                    newValue: {
+                                        ...supersedingItemData,
+                                        supersedes: [...((_c = supersedingItemData.supersedes) !== null && _c !== void 0 ? _c : []), itemRef],
+                                    },
+                                };
+                            }
+                        }
+                        break;
+                }
+                break;
+        }
+    }
+    else {
+        if (newItem === null) {
+            throw new Error("proposalToObjectChangeset() requires new item data for additions");
+        }
+        updatedItem = {
+            id: itemRef.itemID,
+            data: newItem.data,
+            status: 'valid',
+            dateAccepted: new Date(),
+        };
+    }
+    changeset[itemPath] = {
+        oldValue: origItem,
+        newValue: updatedItem,
+    };
+    return changeset;
+}
+//# sourceMappingURL=objectChangeset.js.map

package/compiled/proposals/queries.js

@@ -0,0 +1,5 @@
+/** Basic predicate/query to get just group proposal entry points (main.yaml) */
+export const CR_BASE_QUERY = 'objPath.indexOf("/proposals/") === 0 && objPath.endsWith("main.yaml")';
+/** Predicate/query to get only disposed group proposals */
+export const DISPOSED_CR_QUERY = 'obj.timeDisposed !== undefined && obj.timeDisposed !== null';
+//# sourceMappingURL=queries.js.map

package/compiled/proposals/types.js

@@ -0,0 +1,229 @@
+/**
+ * Proposals, group proposals,
+ * group proposal states and state transitions.
+ */
+export const ChangeProposalType = {
+    ADDITION: 'addition',
+    CLARIFICATION: 'clarification',
+    AMENDMENT: 'amendment',
+};
+export const PROPOSAL_TYPES = [
+    ChangeProposalType.ADDITION,
+    ChangeProposalType.CLARIFICATION,
+    ChangeProposalType.AMENDMENT,
+];
+export const AmendmentType = {
+    SUPERSESSION: 'supersession',
+    RETIREMENT: 'retirement',
+    INVALIDATION: 'invalidation',
+};
+export const AMENDMENT_TYPES = [
+    AmendmentType.SUPERSESSION,
+    AmendmentType.RETIREMENT,
+    AmendmentType.INVALIDATION,
+];
+export function isBaseProposal(val) {
+    return PROPOSAL_TYPES.indexOf(val === null || val === void 0 ? void 0 : val.type) >= 0;
+}
+export function isProposal(val) {
+    return (isBaseProposal(val) && (isAddition(val)
+        || isClarification(val)
+        || isAmendment(val)));
+}
+export function isAddition(val) {
+    return (val.type === ChangeProposalType.ADDITION);
+}
+export function isClarification(val) {
+    return (val.type === ChangeProposalType.CLARIFICATION);
+}
+export function isBaseAmendment(val) {
+    return (val.type === ChangeProposalType.AMENDMENT
+        && AMENDMENT_TYPES.indexOf(val.amendmentType) >= 0);
+}
+export function isAmendment(val) {
+    return (isBaseAmendment(val) && (isRetirement(val)
+        || isSupersession(val)
+        || isInvalidation(val)));
+}
+export function isRetirement(val) {
+    return val.amendmentType === AmendmentType.RETIREMENT;
+}
+export function isSupersession(val) {
+    return val.amendmentType === AmendmentType.SUPERSESSION;
+}
+export function isInvalidation(val) {
+    return val.amendmentType === AmendmentType.INVALIDATION;
+}
+// Change request types, states and state transitions.
+export function isSubmittedBy(stakeholder, cr) {
+    return (
+    //isSubmitter(stakeholder) &&
+    stakeholder.gitServerUsername === cr.submittingStakeholderGitServerUsername);
+}
+// =====================
+// Change request states
+// =====================
+/** Used in place of enum for convenience. */
+export const State = {
+    DRAFT: 'draft',
+    PROPOSED: 'proposed',
+    SUBMITTED_FOR_CONTROL_BODY_REVIEW: 'pending-control-body-review',
+    RETURNED_FOR_CLARIFICATION: 'returned-for-clarification',
+    WITHDRAWN: 'withdrawn',
+    ACCEPTED: 'accepted',
+    REJECTED: 'rejected',
+    APPEALED: 'rejection-appealed-to-owner',
+    ACCEPTED_ON_APPEAL: 'accepted-on-appeal',
+    REJECTION_UPHELD_ON_APPEAL: 'rejection-upheld-on-appeal',
+    APPEAL_WITHDRAWN: 'appeal-withdrawn',
+};
+export function isState(val) {
+    return Object.values(State).indexOf(val) >= 0;
+}
+/** A subset of `State` that represents editable states. */
+export const EditableState = [
+    State.DRAFT,
+    State.RETURNED_FOR_CLARIFICATION,
+];
+export function isEditableState(state) {
+    return EditableState.indexOf(state) >= 0;
+}
+export function isCreatedBy(stakeholder, cr) {
+    var _a;
+    return ((_a = stakeholder.gitServerUsername) === null || _a === void 0 ? void 0 : _a.trim()) !== '' && stakeholder.gitServerUsername === cr.submittingStakeholderGitServerUsername;
+}
+/** Whether given `cr` can be edited (as in, items changed) by specified stakeholder. */
+export function canBeEditedBy(stakeholder, cr) {
+    return isCreatedBy(stakeholder, cr) && isEditableState(cr.state);
+}
+/**
+ * Whether given `cr` can be deleted by given stakeholder.
+ * Unlike editing, deletion is possible only if there are no items
+ * and CR was never proposed.
+ */
+export function canBeDeletedBy(stakeholder, cr) {
+    return (isCreatedBy(stakeholder, cr)
+        && isDrafted(cr)
+        //&& Object.keys(cr.items).length < 1 // Only allow deleting empty CRs
+        && !hadBeenProposed(cr) // If it had been proposed, it should be withdrawn instead.
+    );
+}
+export function isImportableCR(val) {
+    // TODO: More complete check
+    return (val.proposalDraft.id
+        && isDrafted(val.proposalDraft)
+        && Object.keys(val.itemPayloads).length > 0);
+}
+export function isDrafted(cr) {
+    return isInState(cr, State.DRAFT);
+}
+export function isProposed(cr) {
+    return isInState(cr, State.PROPOSED);
+}
+export function isWithdrawn(cr) {
+    return isInState(cr, State.WITHDRAWN);
+}
+/** CR was proposed at least once. */
+export function hadBeenProposed(cr) {
+    return cr && cr.hasOwnProperty('timeProposed') && !!cr.timeProposed;
+}
+export function hadBeenAccepted(cr) {
+    return isDisposed(cr) && (isAccepted(cr) || isAcceptedOnAppeal(cr));
+}
+/** A proposal that had been disposed is not pending, not actionable. */
+export function isDisposed(cr) {
+    return cr && cr.hasOwnProperty('timeDisposed') && !!cr.timeDisposed;
+    // TODO: include status checks, too?
+    //return [
+    //  State.WITHDRAWN,
+    //  State.ACCEPTED,
+    //  State.REJECTED,
+    //  State.REJECTION_UPHELD_ON_APPEAL,
+    //  State.ACCEPTED_ON_APPEAL,
+    //].some(s => cr.state === s);
+}
+export function isSubmittedForControlBodyReview(cr) {
+    return isInState(cr, State.SUBMITTED_FOR_CONTROL_BODY_REVIEW);
+}
+export function isReturnedForClarification(cr) {
+    return isInState(cr, State.RETURNED_FOR_CLARIFICATION);
+}
+export function isAccepted(cr) {
+    return isInState(cr, State.ACCEPTED);
+}
+export function isRejected(cr) {
+    return isInState(cr, State.REJECTED);
+}
+export function isAppealed(cr) {
+    return isInState(cr, State.APPEALED);
+}
+export function isRejectedOnAppeal(cr) {
+    return isInState(cr, State.REJECTION_UPHELD_ON_APPEAL);
+}
+export function isAcceptedOnAppeal(cr) {
+    return isInState(cr, State.ACCEPTED_ON_APPEAL);
+}
+export function isRejectedWithAppealWithdrawn(cr) {
+    return isInState(cr, State.APPEAL_WITHDRAWN);
+}
+export function hasSubmitterInput(val) {
+    return val.hasOwnProperty('justification') && typeof val.justification === 'string';
+}
+export function hasRegisterManagerInput(val) {
+    return val.hasOwnProperty('registerManagerNotes') && typeof val.registerManagerNotes === 'string';
+}
+export function hasControlBodyInput(val) {
+    return (
+    //val.hasOwnProperty('controlBodyNotes') && typeof val.controlBodyNotes === 'string' &&
+    val.hasOwnProperty('controlBodyDecisionEvent') && typeof val.controlBodyDecisionEvent === 'string');
+}
+export function hasAppealRequest(val) {
+    return val.hasOwnProperty('appealReason') && typeof val.appealReason === 'string';
+}
+export function hasRegisterOwnerInput(val) {
+    return val.hasOwnProperty('registerOwnerNotes') && typeof val.registerOwnerNotes === 'string';
+}
+/**
+ * CR type guard helper.
+ * Normally you would not use it directly and instead use
+ * more specific is[Type]() helper from this module.
+ *
+ * Checks CR type using the `state` property.
+ * Does not validate other properties.
+ *
+ * Usage:
+ *
+ * @example
+ * ```ts
+ * let someCR;
+ * if (isInState<Drafted>(someCR, State.DRAFT)) {
+ *   // Can assume someCR is Drafted
+ * }
+ * ```
+ *
+ * It’ll try to tell you if you mismatch those.
+ *
+ * @example
+ * Will not compile:
+ * ```ts
+ * let someCR;
+ * if (isInState<Drafted>(someCR, State.PROPOSED)) {
+ *   // Compile error
+ *   // because State.PROPOSED is not a possible value of Drafted["state"]
+ * }
+ * ```
+ *
+ * @example
+ * Incorrect usage (do not do this):
+ * ```ts
+ * let someCR;
+ * if (isInState(someCR, State.DRAFT)) {
+ *   // Can NOT assume someCR is Drafted
+ *   // The compiler must know the expected concrete CR type
+ * }
+ * ```
+ */
+function isInState(cr, s) {
+    return cr.state === s;
+}
+//# sourceMappingURL=types.js.map

package/compiled/types/index.js

@@ -0,0 +1,7 @@
+export * from './views';
+export * from './register';
+export * from './registry';
+export * from './item';
+export * from './stakeholder';
+export * from './util';
+//# sourceMappingURL=index.js.map