@tomorrowevening/theatre-studio 1.0.5 → 1.0.6

package/dist/panels/SequenceEditorPanel/VerticalScrollContainer.js

@@ -1,42 +0,0 @@
-import noop from '@tomorrowevening/theatre-shared/utils/noop';
-import React, { createContext, useCallback, useContext, useRef } from 'react';
-import styled from 'styled-components';
-import { zIndexes } from './SequenceEditorPanel';
-const Container = styled.div `
-  position: absolute;
-  top: 0;
-  right: 0;
-  left: 0;
-  bottom: 0;
-  overflow-x: hidden;
-  overflow-y: scroll;
-  z-index: ${() => zIndexes.scrollableArea};
-
-  &::-webkit-scrollbar {
-    display: none;
-  }
-
-  scrollbar-width: none;
-`;
-const ctx = createContext(noop);
-/**
- * See {@link VerticalScrollContainer} and references for how to use this.
- */
-export const useReceiveVerticalWheelEvent = () => useContext(ctx);
-/**
- * This is used in the sequence editor where we block wheel events to handle
- * pan/zoom on the time axis. The issue this solves, is that when blocking those
- * wheel events, we prevent the vertical scroll events from being fired. This container
- * comes with a context and a hook (see {@link useReceiveVerticalWheelEvent}) that allows
- * the code that traps the wheel events to pass them to the vertical scroller root, which
- * we then use to manually dispatch scroll events.
- */
-const VerticalScrollContainer = (props) => {
-    const ref = useRef(null);
-    const receiveVerticalWheelEvent = useCallback((event) => {
-        ref.current.scrollBy(0, event.deltaY);
-    }, []);
-    return (React.createElement(ctx.Provider, { value: receiveVerticalWheelEvent },
-        React.createElement(Container, { ref: ref }, props.children)));
-};
-export default VerticalScrollContainer;

package/dist/panels/SequenceEditorPanel/layout/layout.js

@@ -1,166 +0,0 @@
-import getStudio from '@tomorrowevening/theatre-studio/getStudio';
-import subPrism from '@tomorrowevening/theatre-shared/utils/subPrism';
-import { valToAtom } from '@tomorrowevening/theatre-shared/utils/valToAtom';
-import { Atom, prism, val } from '@tomorrowevening/theatre-dataverse';
-import { calculateSequenceEditorTree } from './tree';
-import { clamp } from 'lodash-es';
-// type UnitSpaceProression = number
-// type ClippedSpaceProgression = number
-/**
- * This means the left side of the panel is 20% of its width, and the
- * right side is 80%
- */
-const panelSplitRatio = 0.2;
-const initialClippedSpaceRange = { start: 0, end: 10 };
-export function sequenceEditorPanelLayout(sheet, panelDimsP) {
-    const studio = getStudio();
-    const ahistoricStateP = studio.atomP.ahistoric.projects.stateByProjectId[sheet.address.projectId]
-        .stateBySheetId[sheet.address.sheetId];
-    const historicStateP = studio.atomP.historic.projects.stateByProjectId[sheet.address.projectId]
-        .stateBySheetId[sheet.address.sheetId];
-    return prism(() => {
-        const tree = subPrism('tree', () => calculateSequenceEditorTree(sheet, studio), []);
-        const panelDims = val(panelDimsP);
-        const graphEditorState = val(studio.atomP.historic.panels.sequenceEditor.graphEditor);
-        const selectedPropsByObject = val(historicStateP.sequenceEditor.selectedPropsByObject);
-        const graphEditorAvailable = !!selectedPropsByObject && Object.keys(selectedPropsByObject).length > 0;
-        const { leftDims, rightDims, graphEditorDims, dopeSheetDims, horizontalScrollbarDims, } = prism.memo('leftDims', () => {
-            const leftDims = {
-                width: Math.floor(panelDims.width * panelSplitRatio),
-                height: panelDims.height,
-                screenX: panelDims.screenX,
-                screenY: panelDims.screenY,
-            };
-            const rightDims = {
-                width: panelDims.width - leftDims.width,
-                height: panelDims.height,
-                screenX: (panelDims.screenX +
-                    leftDims.width),
-                screenY: panelDims.screenY,
-            };
-            const graphEditorOpen = graphEditorAvailable && graphEditorState?.isOpen === true;
-            const graphEditorHeight = Math.floor((graphEditorOpen
-                ? clamp(graphEditorState?.height ?? 0.5, 0.1, 0.7)
-                : 0) * panelDims.heightWithoutBorder);
-            const bottomHeight = 0 + graphEditorHeight;
-            const dopeSheetHeight = panelDims.height - bottomHeight;
-            const dopeSheetDims = {
-                width: panelDims.width,
-                height: dopeSheetHeight,
-                screenX: panelDims.screenX,
-                screenY: panelDims.screenY,
-            };
-            // const graphEditorHeight = panelDims.height - dopeSheetDims.height
-            const graphEditorDims = {
-                isAvailable: graphEditorAvailable,
-                isOpen: graphEditorOpen,
-                width: rightDims.width,
-                height: graphEditorHeight,
-                screenX: panelDims.screenX,
-                screenY: panelDims.screenY + dopeSheetHeight,
-                padding: {
-                    top: 20,
-                    bottom: 20,
-                },
-            };
-            const horizontalScrollbarDims = {
-                bottom: graphEditorOpen ? 0 : 0,
-            };
-            return {
-                leftDims,
-                rightDims,
-                graphEditorDims,
-                dopeSheetDims,
-                horizontalScrollbarDims,
-            };
-        }, [panelDims, graphEditorState, graphEditorAvailable]);
-        const graphEditorVerticalSpace = prism.memo('graphEditorVerticalSpace', () => {
-            const space = graphEditorDims.height -
-                graphEditorDims.padding.top -
-                graphEditorDims.padding.bottom;
-            return {
-                space,
-                fromExtremumSpace(ex) {
-                    return ex * space;
-                },
-                toExtremumSpace(s) {
-                    return s / space;
-                },
-            };
-        }, [graphEditorDims]);
-        const [isSeeking, setIsSeeking] = prism.state('isSeeking', false);
-        const seeker = {
-            isSeeking,
-            setIsSeeking,
-        };
-        const unitSpace = {};
-        const clippedSpaceRange = val(ahistoricStateP.sequence.clippedSpaceRange) ??
-            initialClippedSpaceRange;
-        const scaledSpace = prism.memo('scaledSpace', () => {
-            const unitsShownInClippedSpace = clippedSpaceRange.end - clippedSpaceRange.start;
-            const pixelsShownInClippedSpace = rightDims.width;
-            const unitToPixelRatio = unitsShownInClippedSpace / pixelsShownInClippedSpace;
-            const pixelToUnitRatio = pixelsShownInClippedSpace / unitsShownInClippedSpace;
-            return {
-                fromUnitSpace(u) {
-                    return u * pixelToUnitRatio;
-                },
-                toUnitSpace(s) {
-                    return s * unitToPixelRatio;
-                },
-                leftPadding: 10,
-            };
-        }, [clippedSpaceRange, rightDims.width]);
-        const setClippedSpaceRange = prism.memo('setClippedSpaceRange', () => {
-            return function setClippedSpaceRange(_range) {
-                studio.transaction(({ stateEditors }) => {
-                    const range = { ..._range };
-                    if (range.end <= range.start) {
-                        range.end = range.start + 1;
-                    }
-                    if (range.start < 0) {
-                        const length = range.end - range.start;
-                        range.start = 0;
-                        range.end = length;
-                    }
-                    stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId.sequence.clippedSpaceRange.set({ ...sheet.address, range });
-                });
-            };
-        }, []);
-        const clippedSpace = prism.memo('clippedSpace', () => {
-            return {
-                range: clippedSpaceRange,
-                width: rightDims.width,
-                fromUnitSpace(u) {
-                    return (scaledSpace.fromUnitSpace(u - clippedSpaceRange.start) +
-                        scaledSpace.leftPadding);
-                },
-                toUnitSpace(c) {
-                    return (scaledSpace.toUnitSpace(c - scaledSpace.leftPadding) +
-                        clippedSpaceRange.start);
-                },
-                setRange: setClippedSpaceRange,
-            };
-        }, [clippedSpaceRange, rightDims.width, scaledSpace, setClippedSpaceRange]);
-        const selectionAtom = prism.memo('selection.current', () => {
-            return new Atom({});
-        }, []);
-        const finalAtom = valToAtom('finalAtom', {
-            sheet,
-            tree,
-            panelDims,
-            leftDims,
-            rightDims,
-            dopeSheetDims,
-            horizontalScrollbarDims,
-            seeker,
-            unitSpace,
-            scaledSpace,
-            clippedSpace,
-            graphEditorDims,
-            graphEditorVerticalSpace,
-            selectionAtom,
-        });
-        return finalAtom.pointer;
-    });
-}

package/dist/panels/SequenceEditorPanel/layout/tree.js

@@ -1,139 +0,0 @@
-import { createStudioSheetItemKey } from '@tomorrowevening/theatre-shared/utils/ids';
-import { prism, val, pointerToPrism } from '@tomorrowevening/theatre-dataverse';
-import logger from '@tomorrowevening/theatre-shared/logger';
-import { titleBarHeight } from '@tomorrowevening/theatre-studio/panels/BasePanel/common';
-const HEIGHT_OF_ANY_TITLE = 28;
-/**
- * Must run inside prism()
- */
-export const calculateSequenceEditorTree = (sheet, studio) => {
-    prism.ensurePrism();
-    const rootShouldRender = true;
-    let topSoFar = titleBarHeight + (rootShouldRender ? HEIGHT_OF_ANY_TITLE : 0);
-    let nSoFar = 0;
-    const collapsableItemSetP = studio.atomP.ahistoric.projects.stateByProjectId[sheet.address.projectId]
-        .stateBySheetId[sheet.address.sheetId].sequence.collapsableItems;
-    const isCollapsedP = collapsableItemSetP.byId[createStudioSheetItemKey.forSheet()].isCollapsed;
-    const isCollapsed = pointerToPrism(isCollapsedP).getValue() ?? false;
-    const tree = {
-        type: 'sheet',
-        isCollapsed,
-        sheet,
-        children: [],
-        sheetItemKey: createStudioSheetItemKey.forSheet(),
-        shouldRender: rootShouldRender,
-        top: titleBarHeight,
-        depth: 0,
-        n: nSoFar,
-        nodeHeight: rootShouldRender ? HEIGHT_OF_ANY_TITLE : 0,
-        heightIncludingChildren: -1, // calculated below
-    };
-    if (rootShouldRender) {
-        nSoFar += 1;
-    }
-    for (const sheetObject of Object.values(val(sheet.objectsP))) {
-        if (sheetObject) {
-            addObject(sheetObject, tree.children, tree.depth + 1, rootShouldRender && !isCollapsed);
-        }
-    }
-    tree.heightIncludingChildren = topSoFar - tree.top;
-    function addObject(sheetObject, arrayOfChildren, level, shouldRender) {
-        const trackSetups = val(sheetObject.template.getMapOfValidSequenceTracks_forStudio());
-        const objectConfig = val(sheetObject.template.configPointer);
-        if (Object.keys(trackSetups).length === 0)
-            return;
-        const isCollapsedP = collapsableItemSetP.byId[createStudioSheetItemKey.forSheetObject(sheetObject)].isCollapsed;
-        const isCollapsed = pointerToPrism(isCollapsedP).getValue() ?? false;
-        const row = {
-            type: 'sheetObject',
-            isCollapsed,
-            sheetItemKey: createStudioSheetItemKey.forSheetObject(sheetObject),
-            shouldRender,
-            top: topSoFar,
-            children: [],
-            depth: level,
-            n: nSoFar,
-            sheetObject: sheetObject,
-            nodeHeight: shouldRender ? HEIGHT_OF_ANY_TITLE : 0,
-            heightIncludingChildren: -1, // calculated below
-        };
-        arrayOfChildren.push(row);
-        if (shouldRender) {
-            nSoFar += 1;
-            // As we add rows to the tree, top to bottom, we accumulate the pixel
-            // distance to the top of the tree from the bottom of the current row:
-            topSoFar += row.nodeHeight;
-        }
-        addProps(sheetObject, trackSetups, [], objectConfig, row.children, level + 1, shouldRender && !isCollapsed);
-        row.heightIncludingChildren = topSoFar - row.top;
-    }
-    function addProps(sheetObject, trackSetups, pathSoFar, parentPropConfig, arrayOfChildren, level, shouldRender) {
-        for (const [propKey, setupOrSetups] of Object.entries(trackSetups)) {
-            const propConfig = parentPropConfig.props[propKey];
-            addProp(sheetObject, setupOrSetups, [...pathSoFar, propKey], propConfig, arrayOfChildren, level, shouldRender);
-        }
-    }
-    function addProp(sheetObject, trackIdOrMapping, pathToProp, conf, arrayOfChildren, level, shouldRender) {
-        if (conf.type === 'compound') {
-            const trackMapping = trackIdOrMapping;
-            addProp_compound(sheetObject, trackMapping, conf, pathToProp, conf, arrayOfChildren, level, shouldRender);
-        }
-        else if (conf.type === 'enum') {
-            logger.warn('Prop type enum is not yet supported in the sequence editor');
-        }
-        else {
-            const trackId = trackIdOrMapping;
-            addProp_primitive(sheetObject, trackId, pathToProp, conf, arrayOfChildren, level, shouldRender);
-        }
-    }
-    function addProp_compound(sheetObject, trackMapping, propConf, pathToProp, conf, arrayOfChildren, level, shouldRender) {
-        const isCollapsedP = collapsableItemSetP.byId[createStudioSheetItemKey.forSheetObjectProp(sheetObject, pathToProp)].isCollapsed;
-        const isCollapsed = pointerToPrism(isCollapsedP).getValue() ?? false;
-        const row = {
-            type: 'propWithChildren',
-            isCollapsed,
-            propConf,
-            pathToProp,
-            sheetItemKey: createStudioSheetItemKey.forSheetObjectProp(sheetObject, pathToProp),
-            sheetObject: sheetObject,
-            shouldRender,
-            top: topSoFar,
-            children: [],
-            nodeHeight: shouldRender ? HEIGHT_OF_ANY_TITLE : 0,
-            heightIncludingChildren: -1,
-            depth: level,
-            trackMapping,
-            n: nSoFar,
-        };
-        arrayOfChildren.push(row);
-        if (shouldRender) {
-            topSoFar += row.nodeHeight;
-            nSoFar += 1;
-        }
-        addProps(sheetObject, trackMapping, pathToProp, conf, row.children, level + 1, 
-        // collapsed shouldn't render child props
-        shouldRender && !isCollapsed);
-        // }
-        row.heightIncludingChildren = topSoFar - row.top;
-    }
-    function addProp_primitive(sheetObject, trackId, pathToProp, propConf, arrayOfChildren, level, shouldRender) {
-        const row = {
-            type: 'primitiveProp',
-            propConf: propConf,
-            depth: level,
-            sheetItemKey: createStudioSheetItemKey.forSheetObjectProp(sheetObject, pathToProp),
-            sheetObject: sheetObject,
-            pathToProp,
-            shouldRender,
-            top: topSoFar,
-            nodeHeight: shouldRender ? HEIGHT_OF_ANY_TITLE : 0,
-            heightIncludingChildren: shouldRender ? HEIGHT_OF_ANY_TITLE : 0,
-            trackId,
-            n: nSoFar,
-        };
-        arrayOfChildren.push(row);
-        nSoFar += 1;
-        topSoFar += row.nodeHeight;
-    }
-    return tree;
-};

package/dist/panels/SequenceEditorPanel/whatPropIsHighlighted.js

@@ -1,58 +0,0 @@
-import { val } from '@tomorrowevening/theatre-dataverse';
-import { Atom } from '@tomorrowevening/theatre-dataverse';
-import { prism } from '@tomorrowevening/theatre-dataverse';
-import pointerDeep from '@tomorrowevening/theatre-shared/utils/pointerDeep';
-import lodashSet from 'lodash-es/set';
-/** constant global manager */
-export const whatPropIsHighlighted = createWhatPropIsHighlightedState();
-function createWhatPropIsHighlightedState() {
-    let lastLockId = 0;
-    const whatIsHighlighted = new Atom({ hasLock: false });
-    return {
-        replaceLock(address, cleanup) {
-            const lockId = lastLockId++;
-            const existingState = whatIsHighlighted.get();
-            if (existingState.hasLock)
-                existingState.cleanup();
-            whatIsHighlighted.set({
-                hasLock: true,
-                lockId,
-                cleanup,
-                deepPath: arrayToDeepObject(addressToArray(address)),
-            });
-            return function unlock() {
-                const curr = whatIsHighlighted.get();
-                if (curr.hasLock && curr.lockId === lockId) {
-                    curr.cleanup();
-                    whatIsHighlighted.set({ hasLock: false });
-                }
-            };
-        },
-        getIsPropHighlightedD(address) {
-            const highlightedP = pointerDeep(whatIsHighlighted.pointer.deepPath, addressToArray(address));
-            return prism(() => {
-                const value = val(highlightedP);
-                return value === true
-                    ? 'self'
-                    : // obj continues deep path prop from here
-                        value
-                            ? 'descendent'
-                            : // some other prop or no lock
-                                null;
-            });
-        },
-    };
-}
-function addressToArray(address) {
-    return [
-        address.projectId,
-        address.sheetId,
-        address.objectKey,
-        ...address.pathToProp,
-    ];
-}
-function arrayToDeepObject(arr) {
-    const obj = {};
-    lodashSet(obj, arr, true);
-    return obj;
-}

package/dist/propEditors/DefaultValueIndicator.js

@@ -1,64 +0,0 @@
-import { transparentize } from 'polished';
-import React from 'react';
-import styled from 'styled-components';
-import getStudio from '@tomorrowevening/theatre-studio/getStudio';
-import { nextPrevCursorsTheme } from './NextPrevKeyframeCursors';
-import { isPropConfigComposite, iteratePropType, } from '@tomorrowevening/theatre-shared/propTypes/utils';
-const theme = {
-    defaultState: {
-        color: transparentize(0.95, `#C4C4C4`),
-        hoverColor: transparentize(0.15, nextPrevCursorsTheme.onColor),
-    },
-    withStaticOverride: {
-        color: transparentize(0.85, `#C4C4C4`),
-        hoverColor: transparentize(0.15, nextPrevCursorsTheme.onColor),
-    },
-};
-const Container = styled.div `
-  width: 16px;
-  margin: 0 0px 0 2px;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  cursor: pointer;
-
-  color: ${(props) => props.hasStaticOverride
-    ? theme.withStaticOverride.color
-    : theme.defaultState.color};
-
-  &:hover {
-    color: ${(props) => props.hasStaticOverride
-    ? theme.withStaticOverride.hoverColor
-    : theme.defaultState.hoverColor};
-  }
-`;
-const DefaultIcon = styled.div `
-  width: 5px;
-  height: 5px;
-  border-radius: 1px;
-  transform: rotate(45deg);
-  /* border: 1px solid currentColor; */
-  background-color: currentColor;
-`;
-const FilledIcon = styled.div `
-  width: 5px;
-  height: 5px;
-  background-color: currentColor;
-  border-radius: 1px;
-  transform: rotate(45deg);
-`;
-const DefaultOrStaticValueIndicator = (props) => {
-    const { hasStaticOverride, obj, propConfig, pathToProp } = props;
-    const sequenceCb = () => {
-        getStudio().transaction(({ stateEditors }) => {
-            for (const { path, conf } of iteratePropType(propConfig, pathToProp)) {
-                if (isPropConfigComposite(conf))
-                    continue;
-                const propAddress = { ...obj.address, pathToProp: path };
-                stateEditors.coreByProject.historic.sheetsById.sequence.setPrimitivePropAsSequenced(propAddress, propConfig);
-            }
-        });
-    };
-    return (React.createElement(Container, { hasStaticOverride: hasStaticOverride, onClick: sequenceCb, title: "Sequence this prop" }, hasStaticOverride ? (React.createElement(FilledIcon, { title: "The default value is overridden" })) : (React.createElement(DefaultIcon, { title: "This is the default value for this prop" }))));
-};
-export default DefaultOrStaticValueIndicator;

package/dist/propEditors/NextPrevKeyframeCursors.js

@@ -1,135 +0,0 @@
-import { pointerEventsAutoInNormalMode } from '@tomorrowevening/theatre-studio/css';
-import { transparentize } from 'polished';
-import React from 'react';
-import styled, { css } from 'styled-components';
-import { PresenceFlag } from '@tomorrowevening/theatre-studio/uiComponents/usePresence';
-import usePresence from '@tomorrowevening/theatre-studio/uiComponents/usePresence';
-const Container = styled.div `
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  width: 16px;
-  margin: 0 0px 0 2px;
-  position: relative;
-  z-index: 0;
-  opacity: 0.7;
-
-  &:after {
-    position: absolute;
-    left: -14px;
-    right: -14px;
-    top: -2px;
-    bottom: -2px;
-    content: ' ';
-    display: none;
-    z-index: -1;
-    background: ${transparentize(0.2, 'black')};
-  }
-
-  &:hover {
-    opacity: 1;
-    &:after {
-      display: block;
-    }
-  }
-`;
-const Button = styled.div `
-  background: none;
-  position: relative;
-  border: 0;
-  transition: transform 0.1s ease-out;
-  z-index: 0;
-  outline: none;
-  cursor: pointer;
-
-  &:after {
-    display: none;
-    ${Container}:hover & {
-      display: block;
-    }
-    position: absolute;
-    left: -4px;
-    right: -4px;
-    top: -4px;
-    bottom: -4px;
-    content: ' ';
-    z-index: -1;
-  }
-`;
-export const nextPrevCursorsTheme = {
-    offColor: '#555',
-    onColor: '#e0c917',
-};
-const CurButton = styled(Button) `
-  &:hover {
-    color: #e0c917;
-  }
-
-  color: ${(props) => props.presence === PresenceFlag.Primary
-    ? 'white'
-    : props.isOn
-        ? nextPrevCursorsTheme.onColor
-        : nextPrevCursorsTheme.offColor};
-`;
-const pointerEventsNone = css `
-  pointer-events: none !important;
-`;
-const PrevOrNextButton = styled(Button) `
-  color: ${(props) => props.flag === PresenceFlag.Primary
-    ? 'white'
-    : props.available
-        ? nextPrevCursorsTheme.onColor
-        : nextPrevCursorsTheme.offColor};
-
-  ${(props) => props.available ? pointerEventsAutoInNormalMode : pointerEventsNone};
-`;
-const Prev = styled(PrevOrNextButton) `
-  transform: translateX(2px);
-  ${Container}:hover & {
-    transform: translateX(-7px);
-  }
-`;
-const Next = styled(PrevOrNextButton) `
-  transform: translateX(-2px);
-  ${Container}:hover & {
-    transform: translateX(7px);
-  }
-`;
-var Icons;
-(function (Icons) {
-    const Chevron_Group = styled.g `
-    stroke-width: 1;
-    ${PrevOrNextButton}:hover & path {
-      stroke-width: 3;
-    }
-  `;
-    Icons.Prev = () => (React.createElement("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
-        React.createElement(Chevron_Group, { transform: `translate(6 3)` },
-            React.createElement("path", { d: "M4 1L1 4L4 7", stroke: "currentColor" }))));
-    Icons.Next = () => (React.createElement("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
-        React.createElement(Chevron_Group, { transform: `translate(1 3)` },
-            React.createElement("path", { d: "M1 1L4 4L1 7", stroke: "currentColor" }))));
-    const Cur_Group = styled.g `
-    stroke-width: 0;
-    ${CurButton}:hover & path {
-      stroke: currentColor;
-      stroke-width: 2;
-    }
-  `;
-    Icons.Cur = () => (React.createElement("svg", { width: "8", height: "12", viewBox: "0 0 8 12", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
-        React.createElement(Cur_Group, { transform: "translate(1 4)" },
-            React.createElement("path", { d: "M3 0L6 3L3 6L0 3L3 0Z", fill: "currentColor" }))));
-})(Icons || (Icons = {}));
-const NextPrevKeyframeCursors = (props) => {
-    const prevPresence = usePresence(props.prev?.itemKey);
-    const curPresence = usePresence(props.cur?.type === 'on' ? props.cur.itemKey : undefined);
-    const nextPresence = usePresence(props.next?.itemKey);
-    return (React.createElement(Container, null,
-        React.createElement(Prev, { available: !!props.prev, onClick: props.prev?.jump, flag: prevPresence.flag, ...prevPresence.attrs },
-            React.createElement(Icons.Prev, null)),
-        React.createElement(CurButton, { isOn: props.cur.type === 'on', onClick: props.cur.toggle, presence: curPresence.flag, ...curPresence.attrs },
-            React.createElement(Icons.Cur, null)),
-        React.createElement(Next, { available: !!props.next, onClick: props.next?.jump, flag: nextPresence.flag, ...nextPresence.attrs },
-            React.createElement(Icons.Next, null))));
-};
-export default NextPrevKeyframeCursors;

package/dist/propEditors/getNearbyKeyframesOfTrack.js

@@ -1,46 +0,0 @@
-import { createStudioSheetItemKey } from '@tomorrowevening/theatre-shared/utils/ids';
-const cache = new WeakMap();
-const noKeyframes = {};
-export function getNearbyKeyframesOfTrack(obj, track, sequencePosition) {
-    if (!track || track.data.keyframes.length === 0)
-        return noKeyframes;
-    const cachedItem = cache.get(track.data);
-    if (cachedItem && cachedItem[0] === sequencePosition) {
-        return cachedItem[1];
-    }
-    function getKeyframeWithTrackId(idx) {
-        if (!track)
-            return;
-        const found = track.data.keyframes[idx];
-        return (found && {
-            kf: found,
-            track,
-            itemKey: createStudioSheetItemKey.forTrackKeyframe(obj, track.id, found.id),
-        });
-    }
-    const calculate = () => {
-        const nextOrCurIdx = track.data.keyframes.findIndex((kf) => kf.position >= sequencePosition);
-        if (nextOrCurIdx === -1) {
-            return {
-                prev: getKeyframeWithTrackId(track.data.keyframes.length - 1),
-            };
-        }
-        const nextOrCur = getKeyframeWithTrackId(nextOrCurIdx);
-        if (nextOrCur.kf.position === sequencePosition) {
-            return {
-                prev: getKeyframeWithTrackId(nextOrCurIdx - 1),
-                cur: nextOrCur,
-                next: getKeyframeWithTrackId(nextOrCurIdx + 1),
-            };
-        }
-        else {
-            return {
-                next: nextOrCur,
-                prev: getKeyframeWithTrackId(nextOrCurIdx - 1),
-            };
-        }
-    };
-    const result = calculate();
-    cache.set(track.data, [sequencePosition, result]);
-    return result;
-}

package/dist/propEditors/simpleEditors/BooleanPropEditor.js

@@ -1,17 +0,0 @@
-import React, { useCallback } from 'react';
-import styled from 'styled-components';
-import BasicCheckbox from '@tomorrowevening/theatre-studio/uiComponents/form/BasicCheckbox';
-const Input = styled(BasicCheckbox) `
-  margin-left: 6px;
-
-  :focus {
-    outline: 1px solid #555;
-  }
-`;
-function BooleanPropEditor({ propConfig, editingTools, value, autoFocus, }) {
-    const onChange = useCallback((el) => {
-        editingTools.permanentlySetValue(Boolean(el.target.checked));
-    }, [propConfig, editingTools]);
-    return React.createElement(Input, { checked: value, onChange: onChange, autoFocus: autoFocus });
-}
-export default BooleanPropEditor;