@tomorrowevening/theatre-studio 1.0.5 → 1.0.6

package/dist/store/stateEditors.js

@@ -1,774 +0,0 @@
-import { commonRootOfPathsToProps } from '@tomorrowevening/theatre-shared/utils/addresses';
-import { encodePathToProp } from '@tomorrowevening/theatre-shared/utils/addresses';
-import { generateKeyframeId, generateSequenceTrackId, } from '@tomorrowevening/theatre-shared/utils/ids';
-import removePathFromObject from '@tomorrowevening/theatre-shared/utils/removePathFromObject';
-import { transformNumber } from '@tomorrowevening/theatre-shared/utils/transformNumber';
-import { current } from 'immer';
-import findLastIndex from 'lodash-es/findLastIndex';
-import keyBy from 'lodash-es/keyBy';
-import pullFromArray from 'lodash-es/pull';
-import set from 'lodash-es/set';
-import sortBy from 'lodash-es/sortBy';
-import { graphEditorColors } from '@tomorrowevening/theatre-studio/panels/SequenceEditorPanel/GraphEditor/GraphEditor';
-import { clamp, uniq } from 'lodash-es';
-import { isProject, isSheet, isSheetObject, isSheetObjectTemplate, isSheetTemplate, } from '@tomorrowevening/theatre-shared/instanceTypes';
-import { pointableSetUtil } from '@tomorrowevening/theatre-shared/utils/PointableSet';
-export const setDrafts__onlyMeantToBeCalledByTransaction = (drafts) => {
-    currentDrafts = drafts;
-    return stateEditors;
-};
-let currentDrafts;
-const drafts = () => {
-    if (currentDrafts === undefined) {
-        throw new Error(`Calling stateEditors outside of a transaction is not allowed.`);
-    }
-    return currentDrafts;
-};
-var stateEditors;
-(function (stateEditors) {
-    let studio;
-    (function (studio) {
-        let historic;
-        (function (historic) {
-            let panelPositions;
-            (function (panelPositions) {
-                function setPanelPosition(p) {
-                    const h = drafts().historic;
-                    h.panelPositions ??= {};
-                    h.panelPositions[p.panelId] = p.position;
-                }
-                panelPositions.setPanelPosition = setPanelPosition;
-            })(panelPositions = historic.panelPositions || (historic.panelPositions = {}));
-            let panels;
-            (function (panels_1) {
-                function _ensure() {
-                    drafts().historic.panels ??= {};
-                    return drafts().historic.panels;
-                }
-                panels_1._ensure = _ensure;
-                let outline;
-                (function (outline) {
-                    function _ensure() {
-                        const panels = stateEditors.studio.historic.panels._ensure();
-                        panels.outlinePanel ??= {};
-                        return panels.outlinePanel;
-                    }
-                    outline._ensure = _ensure;
-                    let selection;
-                    (function (selection_1) {
-                        function set(selection) {
-                            const newSelectionState = [];
-                            for (const item of uniq(selection)) {
-                                if (isProject(item)) {
-                                    newSelectionState.push({ type: 'Project', ...item.address });
-                                }
-                                else if (isSheet(item)) {
-                                    newSelectionState.push({
-                                        type: 'Sheet',
-                                        ...item.template.address,
-                                    });
-                                    stateEditors.studio.historic.projects.stateByProjectId.stateBySheetId.setSelectedInstanceId(item.address);
-                                }
-                                else if (isSheetTemplate(item)) {
-                                    newSelectionState.push({ type: 'Sheet', ...item.address });
-                                }
-                                else if (isSheetObject(item)) {
-                                    newSelectionState.push({
-                                        type: 'SheetObject',
-                                        ...item.template.address,
-                                    });
-                                    stateEditors.studio.historic.projects.stateByProjectId.stateBySheetId.setSelectedInstanceId(item.sheet.address);
-                                }
-                                else if (isSheetObjectTemplate(item)) {
-                                    newSelectionState.push({ type: 'SheetObject', ...item.address });
-                                }
-                            }
-                            outline._ensure().selection = newSelectionState;
-                        }
-                        selection_1.set = set;
-                        function unset() {
-                            outline._ensure().selection = [];
-                        }
-                        selection_1.unset = unset;
-                    })(selection = outline.selection || (outline.selection = {}));
-                })(outline = panels_1.outline || (panels_1.outline = {}));
-                let sequenceEditor;
-                (function (sequenceEditor) {
-                    function _ensure() {
-                        const panels = stateEditors.studio.historic.panels._ensure();
-                        panels.sequenceEditor ??= {};
-                        return panels.sequenceEditor;
-                    }
-                    sequenceEditor._ensure = _ensure;
-                    let graphEditor;
-                    (function (graphEditor) {
-                        function _ensure() {
-                            const s = sequenceEditor._ensure();
-                            s.graphEditor ??= { height: 0.5, isOpen: false };
-                            return s.graphEditor;
-                        }
-                        function setIsOpen(p) {
-                            _ensure().isOpen = p.isOpen;
-                        }
-                        graphEditor.setIsOpen = setIsOpen;
-                    })(graphEditor = sequenceEditor.graphEditor || (sequenceEditor.graphEditor = {}));
-                })(sequenceEditor = panels_1.sequenceEditor || (panels_1.sequenceEditor = {}));
-            })(panels = historic.panels || (historic.panels = {}));
-            let projects;
-            (function (projects) {
-                let stateByProjectId;
-                (function (stateByProjectId) {
-                    function _ensure(p) {
-                        const s = drafts().historic;
-                        if (!s.projects.stateByProjectId[p.projectId]) {
-                            s.projects.stateByProjectId[p.projectId] = {
-                                stateBySheetId: {},
-                            };
-                        }
-                        return s.projects.stateByProjectId[p.projectId];
-                    }
-                    stateByProjectId._ensure = _ensure;
-                    let stateBySheetId;
-                    (function (stateBySheetId) {
-                        function _ensure(p) {
-                            const projectState = stateEditors.studio.historic.projects.stateByProjectId._ensure(p);
-                            if (!projectState.stateBySheetId[p.sheetId]) {
-                                projectState.stateBySheetId[p.sheetId] = {
-                                    selectedInstanceId: undefined,
-                                    sequenceEditor: {
-                                        selectedPropsByObject: {},
-                                    },
-                                };
-                            }
-                            return projectState.stateBySheetId[p.sheetId];
-                        }
-                        stateBySheetId._ensure = _ensure;
-                        function setSelectedInstanceId(p) {
-                            stateEditors.studio.historic.projects.stateByProjectId.stateBySheetId._ensure(p).selectedInstanceId = p.sheetInstanceId;
-                        }
-                        stateBySheetId.setSelectedInstanceId = setSelectedInstanceId;
-                        let sequenceEditor;
-                        (function (sequenceEditor_1) {
-                            function addPropToGraphEditor(p) {
-                                const { selectedPropsByObject } = stateBySheetId._ensure(p).sequenceEditor;
-                                if (!selectedPropsByObject[p.objectKey]) {
-                                    selectedPropsByObject[p.objectKey] = {};
-                                }
-                                const selectedProps = selectedPropsByObject[p.objectKey];
-                                const path = encodePathToProp(p.pathToProp);
-                                const possibleColors = new Set(Object.keys(graphEditorColors));
-                                for (const [_, selectedProps] of Object.entries(current(selectedPropsByObject))) {
-                                    // debugger
-                                    for (const [_, takenColor] of Object.entries(selectedProps)) {
-                                        possibleColors.delete(takenColor);
-                                    }
-                                }
-                                const color = possibleColors.size > 0
-                                    ? possibleColors.values().next().value
-                                    : Object.keys(graphEditorColors)[0];
-                                selectedProps[path] = color;
-                            }
-                            sequenceEditor_1.addPropToGraphEditor = addPropToGraphEditor;
-                            function removePropFromGraphEditor(p) {
-                                const { selectedPropsByObject } = stateBySheetId._ensure(p).sequenceEditor;
-                                if (!selectedPropsByObject[p.objectKey]) {
-                                    return;
-                                }
-                                const selectedProps = selectedPropsByObject[p.objectKey];
-                                const path = encodePathToProp(p.pathToProp);
-                                if (selectedProps[path]) {
-                                    removePathFromObject(selectedPropsByObject, [
-                                        p.objectKey,
-                                        path,
-                                    ]);
-                                }
-                            }
-                            sequenceEditor_1.removePropFromGraphEditor = removePropFromGraphEditor;
-                            function _ensureMarkers(sheetAddress) {
-                                const sequenceEditor = stateEditors.studio.historic.projects.stateByProjectId.stateBySheetId._ensure(sheetAddress).sequenceEditor;
-                                if (!sequenceEditor.markerSet) {
-                                    sequenceEditor.markerSet = pointableSetUtil.create();
-                                }
-                                return sequenceEditor.markerSet;
-                            }
-                            function replaceMarkers(p) {
-                                const currentMarkerSet = _ensureMarkers(p.sheetAddress);
-                                const sanitizedMarkers = p.markers
-                                    .filter((marker) => {
-                                    if (!isFinite(marker.position))
-                                        return false;
-                                    return true; // marker looks valid
-                                })
-                                    .map((marker) => ({
-                                    ...marker,
-                                    position: p.snappingFunction(marker.position),
-                                }));
-                                const newMarkersById = keyBy(sanitizedMarkers, 'id');
-                                /** Usually starts as the "unselected" markers */
-                                let markersThatArentBeingReplaced = pointableSetUtil.filter(currentMarkerSet, (marker) => marker && !newMarkersById[marker.id]);
-                                const markersThatArentBeingReplacedByPosition = keyBy(Object.values(markersThatArentBeingReplaced.byId), 'position');
-                                // If the new transformed markers overlap with any existing markers,
-                                // we remove the overlapped markers
-                                sanitizedMarkers.forEach(({ position }) => {
-                                    const existingMarkerAtThisPosition = markersThatArentBeingReplacedByPosition[position];
-                                    if (existingMarkerAtThisPosition) {
-                                        markersThatArentBeingReplaced = pointableSetUtil.remove(markersThatArentBeingReplaced, existingMarkerAtThisPosition.id);
-                                    }
-                                });
-                                Object.assign(currentMarkerSet, pointableSetUtil.merge([
-                                    markersThatArentBeingReplaced,
-                                    pointableSetUtil.create(sanitizedMarkers.map((marker) => [marker.id, marker])),
-                                ]));
-                            }
-                            sequenceEditor_1.replaceMarkers = replaceMarkers;
-                            function removeMarker(options) {
-                                const currentMarkerSet = _ensureMarkers(options.sheetAddress);
-                                Object.assign(currentMarkerSet, pointableSetUtil.remove(currentMarkerSet, options.markerId));
-                            }
-                            sequenceEditor_1.removeMarker = removeMarker;
-                            function updateMarker(options) {
-                                const currentMarkerSet = _ensureMarkers(options.sheetAddress);
-                                const marker = currentMarkerSet.byId[options.markerId];
-                                if (marker !== undefined)
-                                    marker.label = options.label;
-                            }
-                            sequenceEditor_1.updateMarker = updateMarker;
-                        })(sequenceEditor = stateBySheetId.sequenceEditor || (stateBySheetId.sequenceEditor = {}));
-                    })(stateBySheetId = stateByProjectId.stateBySheetId || (stateByProjectId.stateBySheetId = {}));
-                })(stateByProjectId = projects.stateByProjectId || (projects.stateByProjectId = {}));
-            })(projects = historic.projects || (historic.projects = {}));
-        })(historic = studio.historic || (studio.historic = {}));
-        let ephemeral;
-        (function (ephemeral) {
-            function setShowOutline(showOutline) {
-                drafts().ephemeral.showOutline = showOutline;
-            }
-            ephemeral.setShowOutline = setShowOutline;
-            let projects;
-            (function (projects) {
-                let stateByProjectId;
-                (function (stateByProjectId) {
-                    function _ensure(p) {
-                        const s = drafts().ephemeral;
-                        if (!s.projects.stateByProjectId[p.projectId]) {
-                            s.projects.stateByProjectId[p.projectId] = {
-                                stateBySheetId: {},
-                            };
-                        }
-                        return s.projects.stateByProjectId[p.projectId];
-                    }
-                    stateByProjectId._ensure = _ensure;
-                    let stateBySheetId;
-                    (function (stateBySheetId) {
-                        function _ensure(p) {
-                            const projectState = stateEditors.studio.ephemeral.projects.stateByProjectId._ensure(p);
-                            if (!projectState.stateBySheetId[p.sheetId]) {
-                                projectState.stateBySheetId[p.sheetId] = {
-                                    stateByObjectKey: {},
-                                };
-                            }
-                            return projectState.stateBySheetId[p.sheetId];
-                        }
-                        stateBySheetId._ensure = _ensure;
-                        let stateByObjectKey;
-                        (function (stateByObjectKey) {
-                            function _ensure(p) {
-                                const s = stateEditors.studio.ephemeral.projects.stateByProjectId.stateBySheetId._ensure(p).stateByObjectKey;
-                                s[p.objectKey] ??= {};
-                                return s[p.objectKey];
-                            }
-                            stateByObjectKey._ensure = _ensure;
-                            let propsBeingScrubbed;
-                            (function (propsBeingScrubbed) {
-                                function _ensure(p) {
-                                    const s = stateEditors.studio.ephemeral.projects.stateByProjectId.stateBySheetId.stateByObjectKey._ensure(p);
-                                    s.valuesBeingScrubbed ??= {};
-                                    return s.valuesBeingScrubbed;
-                                }
-                                propsBeingScrubbed._ensure = _ensure;
-                                function flag(p) {
-                                    set(_ensure(p), p.pathToProp, true);
-                                }
-                                propsBeingScrubbed.flag = flag;
-                            })(propsBeingScrubbed = stateByObjectKey.propsBeingScrubbed || (stateByObjectKey.propsBeingScrubbed = {}));
-                        })(stateByObjectKey = stateBySheetId.stateByObjectKey || (stateBySheetId.stateByObjectKey = {}));
-                    })(stateBySheetId = stateByProjectId.stateBySheetId || (stateByProjectId.stateBySheetId = {}));
-                })(stateByProjectId = projects.stateByProjectId || (projects.stateByProjectId = {}));
-            })(projects = ephemeral.projects || (ephemeral.projects = {}));
-        })(ephemeral = studio.ephemeral || (studio.ephemeral = {}));
-        let ahistoric;
-        (function (ahistoric) {
-            function setPinOutline(pinOutline) {
-                drafts().ahistoric.pinOutline = pinOutline;
-            }
-            ahistoric.setPinOutline = setPinOutline;
-            function setPinDetails(pinDetails) {
-                drafts().ahistoric.pinDetails = pinDetails;
-            }
-            ahistoric.setPinDetails = setPinDetails;
-            function setPinNotifications(pinNotifications) {
-                drafts().ahistoric.pinNotifications = pinNotifications;
-            }
-            ahistoric.setPinNotifications = setPinNotifications;
-            function setVisibilityState(visibilityState) {
-                drafts().ahistoric.visibilityState = visibilityState;
-            }
-            ahistoric.setVisibilityState = setVisibilityState;
-            function setClipboardKeyframes(keyframes) {
-                const commonPath = commonRootOfPathsToProps(keyframes.map((kf) => kf.pathToProp));
-                const keyframesWithCommonRootPath = keyframes.map(({ keyframe, pathToProp }) => ({
-                    keyframe,
-                    pathToProp: pathToProp.slice(commonPath.length),
-                }));
-                // save selection
-                const draft = drafts();
-                if (draft.ahistoric.clipboard) {
-                    draft.ahistoric.clipboard.keyframesWithRelativePaths =
-                        keyframesWithCommonRootPath;
-                }
-                else {
-                    draft.ahistoric.clipboard = {
-                        keyframesWithRelativePaths: keyframesWithCommonRootPath,
-                    };
-                }
-            }
-            ahistoric.setClipboardKeyframes = setClipboardKeyframes;
-            let projects;
-            (function (projects) {
-                let stateByProjectId;
-                (function (stateByProjectId) {
-                    function _ensure(p) {
-                        const s = drafts().ahistoric;
-                        if (!s.projects.stateByProjectId[p.projectId]) {
-                            s.projects.stateByProjectId[p.projectId] = {
-                                stateBySheetId: {},
-                            };
-                        }
-                        return s.projects.stateByProjectId[p.projectId];
-                    }
-                    stateByProjectId._ensure = _ensure;
-                    let collapsedItemsInOutline;
-                    (function (collapsedItemsInOutline_1) {
-                        function _ensure(p) {
-                            const projectState = stateEditors.studio.ahistoric.projects.stateByProjectId._ensure(p);
-                            if (!projectState.collapsedItemsInOutline) {
-                                projectState.collapsedItemsInOutline = {};
-                            }
-                            return projectState.collapsedItemsInOutline;
-                        }
-                        collapsedItemsInOutline_1._ensure = _ensure;
-                        function set(p) {
-                            const collapsedItemsInOutline = stateEditors.studio.ahistoric.projects.stateByProjectId.collapsedItemsInOutline._ensure(p);
-                            if (p.isCollapsed) {
-                                collapsedItemsInOutline[p.itemKey] = true;
-                            }
-                            else {
-                                delete collapsedItemsInOutline[p.itemKey];
-                            }
-                        }
-                        collapsedItemsInOutline_1.set = set;
-                    })(collapsedItemsInOutline = stateByProjectId.collapsedItemsInOutline || (stateByProjectId.collapsedItemsInOutline = {}));
-                    let stateBySheetId;
-                    (function (stateBySheetId) {
-                        function _ensure(p) {
-                            const projectState = stateEditors.studio.ahistoric.projects.stateByProjectId._ensure(p);
-                            if (!projectState.stateBySheetId[p.sheetId]) {
-                                projectState.stateBySheetId[p.sheetId] = {};
-                            }
-                            return projectState.stateBySheetId[p.sheetId];
-                        }
-                        stateBySheetId._ensure = _ensure;
-                        let sequence;
-                        (function (sequence) {
-                            function _ensure(p) {
-                                const sheetState = stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId._ensure(p);
-                                if (!sheetState.sequence) {
-                                    sheetState.sequence = {};
-                                }
-                                return sheetState.sequence;
-                            }
-                            sequence._ensure = _ensure;
-                            let focusRange;
-                            (function (focusRange) {
-                                function set(p) {
-                                    stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId.sequence._ensure(p).focusRange = { range: p.range, enabled: p.enabled };
-                                }
-                                focusRange.set = set;
-                                function unset(p) {
-                                    stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId.sequence._ensure(p).focusRange = undefined;
-                                }
-                                focusRange.unset = unset;
-                            })(focusRange = sequence.focusRange || (sequence.focusRange = {}));
-                            let clippedSpaceRange;
-                            (function (clippedSpaceRange) {
-                                function set(p) {
-                                    stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId.sequence._ensure(p).clippedSpaceRange = { ...p.range };
-                                }
-                                clippedSpaceRange.set = set;
-                            })(clippedSpaceRange = sequence.clippedSpaceRange || (sequence.clippedSpaceRange = {}));
-                            let sequenceEditorCollapsableItems;
-                            (function (sequenceEditorCollapsableItems) {
-                                function _ensure(p) {
-                                    const seq = stateEditors.studio.ahistoric.projects.stateByProjectId.stateBySheetId.sequence._ensure(p);
-                                    let existing = seq.collapsableItems;
-                                    if (!existing) {
-                                        existing = seq.collapsableItems = pointableSetUtil.create();
-                                    }
-                                    return existing;
-                                }
-                                function set(p) {
-                                    const collapsableSet = _ensure(p);
-                                    Object.assign(collapsableSet, pointableSetUtil.add(collapsableSet, p.studioSheetItemKey, {
-                                        isCollapsed: p.isCollapsed,
-                                    }));
-                                }
-                                sequenceEditorCollapsableItems.set = set;
-                            })(sequenceEditorCollapsableItems = sequence.sequenceEditorCollapsableItems || (sequence.sequenceEditorCollapsableItems = {}));
-                        })(sequence = stateBySheetId.sequence || (stateBySheetId.sequence = {}));
-                    })(stateBySheetId = stateByProjectId.stateBySheetId || (stateByProjectId.stateBySheetId = {}));
-                })(stateByProjectId = projects.stateByProjectId || (projects.stateByProjectId = {}));
-            })(projects = ahistoric.projects || (ahistoric.projects = {}));
-        })(ahistoric = studio.ahistoric || (studio.ahistoric = {}));
-    })(studio = stateEditors.studio || (stateEditors.studio = {}));
-    let coreByProject;
-    (function (coreByProject) {
-        let historic;
-        (function (historic) {
-            let revisionHistory;
-            (function (revisionHistory_1) {
-                function add(p) {
-                    const revisionHistory = drafts().historic.coreByProject[p.projectId].revisionHistory;
-                    const maxNumOfRevisionsToKeep = 50;
-                    revisionHistory.unshift(p.revision);
-                    if (revisionHistory.length > maxNumOfRevisionsToKeep) {
-                        revisionHistory.length = maxNumOfRevisionsToKeep;
-                    }
-                }
-                revisionHistory_1.add = add;
-            })(revisionHistory = historic.revisionHistory || (historic.revisionHistory = {}));
-            let sheetsById;
-            (function (sheetsById_1) {
-                function _ensure(p) {
-                    const sheetsById = drafts().historic.coreByProject[p.projectId].sheetsById;
-                    if (!sheetsById[p.sheetId]) {
-                        sheetsById[p.sheetId] = { staticOverrides: { byObject: {} } };
-                    }
-                    return sheetsById[p.sheetId];
-                }
-                sheetsById_1._ensure = _ensure;
-                function forgetObject(p) {
-                    const sheetState = drafts().historic.coreByProject[p.projectId].sheetsById[p.sheetId];
-                    if (!sheetState)
-                        return;
-                    delete sheetState.staticOverrides.byObject[p.objectKey];
-                    const sequence = sheetState.sequence;
-                    if (!sequence)
-                        return;
-                    delete sequence.tracksByObject[p.objectKey];
-                }
-                sheetsById_1.forgetObject = forgetObject;
-                function forgetSheet(p) {
-                    const sheetState = drafts().historic.coreByProject[p.projectId].sheetsById[p.sheetId];
-                    if (sheetState) {
-                        delete drafts().historic.coreByProject[p.projectId].sheetsById[p.sheetId];
-                    }
-                }
-                sheetsById_1.forgetSheet = forgetSheet;
-                let sequence;
-                (function (sequence) {
-                    function _ensure(p) {
-                        const s = stateEditors.coreByProject.historic.sheetsById._ensure(p);
-                        s.sequence ??= {
-                            subUnitsPerUnit: 30,
-                            length: 10,
-                            type: 'PositionalSequence',
-                            tracksByObject: {},
-                        };
-                        return s.sequence;
-                    }
-                    sequence._ensure = _ensure;
-                    function setLength(p) {
-                        _ensure(p).length = clamp(parseFloat(p.length.toFixed(2)), 0.01, Infinity);
-                    }
-                    sequence.setLength = setLength;
-                    function setSubUnitsPerUnit(p) {
-                        _ensure(p).subUnitsPerUnit = clamp(p.subUnitsPerUnit, 1, 2 ** 12);
-                    }
-                    sequence.setSubUnitsPerUnit = setSubUnitsPerUnit;
-                    function _ensureTracksOfObject(p) {
-                        const s = stateEditors.coreByProject.historic.sheetsById.sequence._ensure(p).tracksByObject;
-                        s[p.objectKey] ??= { trackData: {}, trackIdByPropPath: {} };
-                        return s[p.objectKey];
-                    }
-                    function setPrimitivePropAsSequenced(p, config) {
-                        const tracks = _ensureTracksOfObject(p);
-                        const pathEncoded = encodePathToProp(p.pathToProp);
-                        const possibleTrackId = tracks.trackIdByPropPath[pathEncoded];
-                        if (typeof possibleTrackId === 'string')
-                            return;
-                        const trackId = generateSequenceTrackId();
-                        const track = {
-                            type: 'BasicKeyframedTrack',
-                            __debugName: `${p.objectKey}:${pathEncoded}`,
-                            keyframes: [],
-                        };
-                        tracks.trackData[trackId] = track;
-                        tracks.trackIdByPropPath[pathEncoded] = trackId;
-                    }
-                    sequence.setPrimitivePropAsSequenced = setPrimitivePropAsSequenced;
-                    function setPrimitivePropAsStatic(p) {
-                        const tracks = _ensureTracksOfObject(p);
-                        const encodedPropPath = encodePathToProp(p.pathToProp);
-                        const trackId = tracks.trackIdByPropPath[encodedPropPath];
-                        if (typeof trackId !== 'string')
-                            return;
-                        delete tracks.trackIdByPropPath[encodedPropPath];
-                        delete tracks.trackData[trackId];
-                        stateEditors.coreByProject.historic.sheetsById.staticOverrides.byObject.setValueOfPrimitiveProp(p);
-                    }
-                    sequence.setPrimitivePropAsStatic = setPrimitivePropAsStatic;
-                    function setCompoundPropAsStatic(p) {
-                        const tracks = _ensureTracksOfObject(p);
-                        for (const encodedPropPath of Object.keys(tracks.trackIdByPropPath)) {
-                            const propPath = JSON.parse(encodedPropPath);
-                            const isSubOfTargetPath = p.pathToProp.every((key, i) => propPath[i] === key);
-                            if (isSubOfTargetPath) {
-                                const trackId = tracks.trackIdByPropPath[encodedPropPath];
-                                if (typeof trackId !== 'string')
-                                    continue;
-                                delete tracks.trackIdByPropPath[encodedPropPath];
-                                delete tracks.trackData[trackId];
-                            }
-                        }
-                        stateEditors.coreByProject.historic.sheetsById.staticOverrides.byObject.setValueOfCompoundProp(p);
-                    }
-                    sequence.setCompoundPropAsStatic = setCompoundPropAsStatic;
-                    function _getTrack(p) {
-                        return _ensureTracksOfObject(p).trackData[p.trackId];
-                    }
-                    function _getKeyframeById(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        return track.keyframes.find((kf) => kf.id === p.keyframeId);
-                    }
-                    /**
-                     * Sets a keyframe at the exact specified position.
-                     * Any position snapping should be done by the caller.
-                     */
-                    function setKeyframeAtPosition(p) {
-                        const position = p.snappingFunction(p.position);
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        const { keyframes } = track;
-                        const existingKeyframeIndex = keyframes.findIndex((kf) => kf.position === position);
-                        if (existingKeyframeIndex !== -1) {
-                            const kf = keyframes[existingKeyframeIndex];
-                            kf.value = p.value;
-                            return;
-                        }
-                        const indexOfLeftKeyframe = findLastIndex(keyframes, (kf) => kf.position < position);
-                        if (indexOfLeftKeyframe === -1) {
-                            keyframes.unshift({
-                                // generating the keyframe within the `setKeyframeAtPosition` makes it impossible for us
-                                // to make this business logic deterministic, which is important to guarantee for collaborative
-                                // editing.
-                                id: generateKeyframeId(),
-                                position,
-                                connectedRight: true,
-                                handles: p.handles || [0.5, 1, 0.5, 0],
-                                type: p.type || 'bezier',
-                                value: p.value,
-                            });
-                            return;
-                        }
-                        const leftKeyframe = keyframes[indexOfLeftKeyframe];
-                        keyframes.splice(indexOfLeftKeyframe + 1, 0, {
-                            id: generateKeyframeId(),
-                            position,
-                            connectedRight: leftKeyframe.connectedRight,
-                            handles: p.handles || [0.5, 1, 0.5, 0],
-                            type: p.type || 'bezier',
-                            value: p.value,
-                        });
-                    }
-                    sequence.setKeyframeAtPosition = setKeyframeAtPosition;
-                    function unsetKeyframeAtPosition(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        const { keyframes } = track;
-                        const index = keyframes.findIndex((kf) => kf.position === p.position);
-                        if (index === -1)
-                            return;
-                        keyframes.splice(index, 1);
-                    }
-                    sequence.unsetKeyframeAtPosition = unsetKeyframeAtPosition;
-                    function transformKeyframes(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        const initialKeyframes = current(track.keyframes);
-                        const selectedKeyframes = initialKeyframes.filter((kf) => p.keyframeIds.includes(kf.id));
-                        const transformed = selectedKeyframes.map((untransformedKf) => {
-                            const oldPosition = untransformedKf.position;
-                            const newPosition = p.snappingFunction(transformNumber(oldPosition, p));
-                            return { ...untransformedKf, position: newPosition };
-                        });
-                        replaceKeyframes({ ...p, keyframes: transformed });
-                    }
-                    sequence.transformKeyframes = transformKeyframes;
-                    /**
-                     * Sets the easing between keyframes
-                     *
-                     * X = in keyframeIds
-                     * * = not in keyframeIds
-                     * + = modified handle
-                     * ```
-                     * X- --- -*- --- -X
-                     * X+ --- +*- --- -X+
-                     * ```
-                     *
-                     * TODO - explain further
-                     */
-                    function setTweenBetweenKeyframes(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        track.keyframes = track.keyframes.map((kf, i) => {
-                            const prevKf = track.keyframes[i - 1];
-                            const isBeingEdited = p.keyframeIds.includes(kf.id);
-                            const isAfterEditedKeyframe = p.keyframeIds.includes(prevKf?.id);
-                            if (isBeingEdited && !isAfterEditedKeyframe) {
-                                return {
-                                    ...kf,
-                                    handles: [
-                                        kf.handles[0],
-                                        kf.handles[1],
-                                        p.handles[0],
-                                        p.handles[1],
-                                    ],
-                                };
-                            }
-                            else if (isBeingEdited && isAfterEditedKeyframe) {
-                                return {
-                                    ...kf,
-                                    handles: [
-                                        p.handles[2],
-                                        p.handles[3],
-                                        p.handles[0],
-                                        p.handles[1],
-                                    ],
-                                };
-                            }
-                            else if (isAfterEditedKeyframe) {
-                                return {
-                                    ...kf,
-                                    handles: [
-                                        p.handles[2],
-                                        p.handles[3],
-                                        kf.handles[2],
-                                        kf.handles[3],
-                                    ],
-                                };
-                            }
-                            else {
-                                return kf;
-                            }
-                        });
-                    }
-                    sequence.setTweenBetweenKeyframes = setTweenBetweenKeyframes;
-                    function setHandlesForKeyframe(p) {
-                        const keyframe = _getKeyframeById(p);
-                        if (keyframe) {
-                            keyframe.handles = [
-                                p.end?.[0] ?? keyframe.handles[0],
-                                p.end?.[1] ?? keyframe.handles[1],
-                                p.start?.[0] ?? keyframe.handles[2],
-                                p.start?.[1] ?? keyframe.handles[3],
-                            ];
-                        }
-                    }
-                    sequence.setHandlesForKeyframe = setHandlesForKeyframe;
-                    function deleteKeyframes(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        track.keyframes = track.keyframes.filter((kf) => p.keyframeIds.indexOf(kf.id) === -1);
-                    }
-                    sequence.deleteKeyframes = deleteKeyframes;
-                    function setKeyframeType(p) {
-                        const kf = _getKeyframeById(p);
-                        if (kf) {
-                            kf.type = p.keyframeType;
-                        }
-                    }
-                    sequence.setKeyframeType = setKeyframeType;
-                    // Future: consider whether a list of "partial" keyframes requiring `id` is possible to accept
-                    //  * Consider how common this pattern is, as this sort of concept would best be encountered
-                    //    a few times to start to see an opportunity for improved ergonomics / crdt.
-                    function replaceKeyframes(p) {
-                        const track = _getTrack(p);
-                        if (!track)
-                            return;
-                        const initialKeyframes = current(track.keyframes);
-                        const sanitizedKeyframes = p.keyframes
-                            .filter((kf) => {
-                            if (typeof kf.value === 'number' && !isFinite(kf.value))
-                                return false;
-                            if (!kf.handles.every((handleValue) => isFinite(handleValue)))
-                                return false;
-                            return true;
-                        })
-                            .map((kf) => ({ ...kf, position: p.snappingFunction(kf.position) }));
-                        const newKeyframesById = keyBy(sanitizedKeyframes, 'id');
-                        const unselected = initialKeyframes.filter((kf) => !newKeyframesById[kf.id]);
-                        const unselectedByPosition = keyBy(unselected, 'position');
-                        // If the new transformed keyframes overlap with any existing keyframes,
-                        // we remove the overlapped keyframes
-                        sanitizedKeyframes.forEach(({ position }) => {
-                            const existingKeyframeAtThisPosition = unselectedByPosition[position];
-                            if (existingKeyframeAtThisPosition) {
-                                pullFromArray(unselected, existingKeyframeAtThisPosition);
-                            }
-                        });
-                        const sorted = sortBy([...unselected, ...sanitizedKeyframes], 'position');
-                        track.keyframes = sorted;
-                    }
-                    sequence.replaceKeyframes = replaceKeyframes;
-                })(sequence = sheetsById_1.sequence || (sheetsById_1.sequence = {}));
-                let staticOverrides;
-                (function (staticOverrides) {
-                    let byObject;
-                    (function (byObject_1) {
-                        function _ensure(p) {
-                            const byObject = stateEditors.coreByProject.historic.sheetsById._ensure(p)
-                                .staticOverrides.byObject;
-                            byObject[p.objectKey] ??= {};
-                            return byObject[p.objectKey];
-                        }
-                        function setValueOfCompoundProp(p) {
-                            const existingOverrides = _ensure(p);
-                            set(existingOverrides, p.pathToProp, p.value);
-                        }
-                        byObject_1.setValueOfCompoundProp = setValueOfCompoundProp;
-                        function setValueOfPrimitiveProp(p) {
-                            const existingOverrides = _ensure(p);
-                            set(existingOverrides, p.pathToProp, p.value);
-                        }
-                        byObject_1.setValueOfPrimitiveProp = setValueOfPrimitiveProp;
-                        function unsetValueOfPrimitiveProp(p) {
-                            const existingStaticOverrides = stateEditors.coreByProject.historic.sheetsById._ensure(p)
-                                .staticOverrides.byObject[p.objectKey];
-                            if (!existingStaticOverrides)
-                                return;
-                            removePathFromObject(existingStaticOverrides, p.pathToProp);
-                        }
-                        byObject_1.unsetValueOfPrimitiveProp = unsetValueOfPrimitiveProp;
-                    })(byObject = staticOverrides.byObject || (staticOverrides.byObject = {}));
-                })(staticOverrides = sheetsById_1.staticOverrides || (sheetsById_1.staticOverrides = {}));
-            })(sheetsById = historic.sheetsById || (historic.sheetsById = {}));
-        })(historic = coreByProject.historic || (coreByProject.historic = {}));
-    })(coreByProject = stateEditors.coreByProject || (stateEditors.coreByProject = {}));
-})(stateEditors || (stateEditors = {}));