@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/store/stateEditors.js

@@ -0,0 +1,774 @@
+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 = {}));