@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/propEditors/simpleEditors/RgbaPropEditor.js

@@ -0,0 +1,73 @@
+import { validHexRegExp } from '@tomorrowevening/theatre-shared/utils/color';
+import { decorateRgba, rgba2hex, parseRgbaFromHex, } from '@tomorrowevening/theatre-shared/utils/color';
+import React, { useCallback, useRef } from 'react';
+import { RgbaColorPicker } from '@tomorrowevening/theatre-studio/uiComponents/colorPicker';
+import styled from 'styled-components';
+import usePopover from '@tomorrowevening/theatre-studio/uiComponents/Popover/usePopover';
+import BasicStringInput from '@tomorrowevening/theatre-studio/uiComponents/form/BasicStringInput';
+import { popoverBackgroundColor } from '@tomorrowevening/theatre-studio/uiComponents/Popover/BasicPopover';
+const RowContainer = styled.div `
+  display: flex;
+  align-items: center;
+  height: 100%;
+  gap: 4px;
+`;
+const ColorPreviewPuck = styled.div.attrs((props) => ({
+    style: {
+        // weirdly, rgba2hex is needed to ensure initial render was correct background?
+        // huge head scratcher.
+        background: rgba2hex(props.rgbaColor),
+    },
+})) `
+  height: 18px;
+  aspect-ratio: 1;
+  border-radius: 99999px;
+`;
+const HexInput = styled(BasicStringInput) `
+  flex: 1;
+`;
+const noop = () => { };
+const RgbaPopover = styled.div `
+  position: absolute;
+  background-color: ${popoverBackgroundColor};
+  color: white;
+  margin: 0;
+  cursor: default;
+  border-radius: 3px;
+  z-index: 10000;
+  backdrop-filter: blur(8px);
+
+  padding: 4px;
+  pointer-events: all;
+
+  border: none;
+  box-shadow: none;
+`;
+function RgbaPropEditor({ editingTools, value, autoFocus, }) {
+    const containerRef = useRef(null);
+    const onChange = useCallback((color) => {
+        const rgba = decorateRgba(parseRgbaFromHex(color));
+        editingTools.permanentlySetValue(rgba);
+    }, [editingTools]);
+    const popover = usePopover({ debugName: 'RgbaPropEditor' }, () => (React.createElement(RgbaPopover, null,
+        React.createElement(RgbaColorPicker, { color: {
+                r: value.r,
+                g: value.g,
+                b: value.b,
+                a: value.a,
+            }, temporarilySetValue: (color) => {
+                const rgba = decorateRgba(color);
+                editingTools.temporarilySetValue(rgba);
+            }, permanentlySetValue: (color) => {
+                const rgba = decorateRgba(color);
+                editingTools.permanentlySetValue(rgba);
+            }, discardTemporaryValue: editingTools.discardTemporaryValue }))));
+    return (React.createElement(React.Fragment, null,
+        React.createElement(RowContainer, null,
+            React.createElement(ColorPreviewPuck, { rgbaColor: value, ref: containerRef, onClick: (e) => {
+                    popover.toggle(e, containerRef.current);
+                } }),
+            React.createElement(HexInput, { value: rgba2hex(value, { removeAlphaIfOpaque: true }), temporarilySetValue: noop, discardTemporaryValue: noop, permanentlySetValue: onChange, isValid: (v) => !!v.match(validHexRegExp), autoFocus: autoFocus })),
+        popover.node));
+}
+export default RgbaPropEditor;

package/dist/propEditors/simpleEditors/StringLiteralPropEditor.d.ts

@@ -0,0 +1,6 @@
+import type { PropTypeConfig_StringLiteral } from '@tomorrowevening/theatre-core/propTypes';
+import React from 'react';
+import type { ISimplePropEditorReactProps } from './ISimplePropEditorReactProps';
+declare function StringLiteralPropEditor<TLiteralOptions extends string>({ propConfig, editingTools, value, autoFocus, }: ISimplePropEditorReactProps<PropTypeConfig_StringLiteral<TLiteralOptions>>): React.JSX.Element;
+export default StringLiteralPropEditor;
+//# sourceMappingURL=StringLiteralPropEditor.d.ts.map

package/dist/propEditors/simpleEditors/StringLiteralPropEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringLiteralPropEditor.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/simpleEditors/StringLiteralPropEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,4BAA4B,EAAC,MAAM,yCAAyC,CAAA;AACzF,OAAO,KAAoB,MAAM,OAAO,CAAA;AAGxC,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAA;AAE9E,iBAAS,uBAAuB,CAAC,eAAe,SAAS,MAAM,EAAE,EAC/D,UAAU,EACV,YAAY,EACZ,KAAK,EACL,SAAS,GACV,EAAE,2BAA2B,CAAC,4BAA4B,CAAC,eAAe,CAAC,CAAC,qBAuB5E;AAED,eAAe,uBAAuB,CAAA"}

package/dist/propEditors/simpleEditors/StringLiteralPropEditor.js

@@ -0,0 +1,10 @@
+import React, { useCallback } from 'react';
+import BasicSwitch from '@tomorrowevening/theatre-studio/uiComponents/form/BasicSwitch';
+import BasicSelect from '@tomorrowevening/theatre-studio/uiComponents/form/BasicSelect';
+function StringLiteralPropEditor({ propConfig, editingTools, value, autoFocus, }) {
+    const onChange = useCallback((val) => {
+        editingTools.permanentlySetValue(val);
+    }, [propConfig, editingTools]);
+    return propConfig.as === 'menu' ? (React.createElement(BasicSelect, { value: value, onChange: onChange, options: propConfig.valuesAndLabels, autoFocus: autoFocus })) : (React.createElement(BasicSwitch, { value: value, onChange: onChange, options: propConfig.valuesAndLabels, autoFocus: autoFocus }));
+}
+export default StringLiteralPropEditor;

package/dist/propEditors/simpleEditors/StringPropEditor.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { PropTypeConfig_String } from '@tomorrowevening/theatre-core/propTypes';
+import type { ISimplePropEditorReactProps } from './ISimplePropEditorReactProps';
+declare function StringPropEditor({ editingTools, value, autoFocus, }: ISimplePropEditorReactProps<PropTypeConfig_String>): React.JSX.Element;
+export default StringPropEditor;
+//# sourceMappingURL=StringPropEditor.d.ts.map

package/dist/propEditors/simpleEditors/StringPropEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringPropEditor.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/simpleEditors/StringPropEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,yCAAyC,CAAA;AAElF,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAA;AAE9E,iBAAS,gBAAgB,CAAC,EACxB,YAAY,EACZ,KAAK,EACL,SAAS,GACV,EAAE,2BAA2B,CAAC,qBAAqB,CAAC,qBAUpD;AAED,eAAe,gBAAgB,CAAA"}

package/dist/propEditors/simpleEditors/StringPropEditor.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import BasicStringInput from '@tomorrowevening/theatre-studio/uiComponents/form/BasicStringInput';
+function StringPropEditor({ editingTools, value, autoFocus, }) {
+    return (React.createElement(BasicStringInput, { value: value, temporarilySetValue: editingTools.temporarilySetValue, discardTemporaryValue: editingTools.discardTemporaryValue, permanentlySetValue: editingTools.permanentlySetValue, autoFocus: autoFocus }));
+}
+export default StringPropEditor;

package/dist/propEditors/simpleEditors/simplePropEditorByPropType.d.ts

@@ -0,0 +1,10 @@
+import type { PropTypeConfig_AllSimples } from '@tomorrowevening/theatre-core/propTypes';
+import type React from 'react';
+import type { ISimplePropEditorReactProps } from './ISimplePropEditorReactProps';
+import type { PropConfigForType } from '@tomorrowevening/theatre-studio/propEditors/utils/PropConfigForType';
+export declare const simplePropEditorByPropType: ISimplePropEditorByPropType;
+type ISimplePropEditorByPropType = {
+    [K in PropTypeConfig_AllSimples['type']]: React.VFC<ISimplePropEditorReactProps<PropConfigForType<K>>>;
+};
+export {};
+//# sourceMappingURL=simplePropEditorByPropType.d.ts.map

package/dist/propEditors/simpleEditors/simplePropEditorByPropType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplePropEditorByPropType.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/simpleEditors/simplePropEditorByPropType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAA;AACtF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAA;AAC9E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,qEAAqE,CAAA;AAI1G,eAAO,MAAM,0BAA0B,EAAE,2BAQxC,CAAA;AAED,KAAK,2BAA2B,GAAG;KAChC,CAAC,IAAI,yBAAyB,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,CACjD,2BAA2B,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAClD;CACF,CAAA"}

package/dist/propEditors/simpleEditors/simplePropEditorByPropType.js

@@ -0,0 +1,16 @@
+import BooleanPropEditor from './BooleanPropEditor';
+import NumberPropEditor from './NumberPropEditor';
+import StringLiteralPropEditor from './StringLiteralPropEditor';
+import StringPropEditor from './StringPropEditor';
+import RgbaPropEditor from './RgbaPropEditor';
+import ImagePropEditor from './ImagePropEditor';
+import FilePropEditor from './FilePropEditor';
+export const simplePropEditorByPropType = {
+    number: NumberPropEditor,
+    string: StringPropEditor,
+    boolean: BooleanPropEditor,
+    stringLiteral: StringLiteralPropEditor,
+    rgba: RgbaPropEditor,
+    image: ImagePropEditor,
+    file: FilePropEditor,
+};

package/dist/propEditors/useEditingToolsForCompoundProp.d.ts

@@ -0,0 +1,27 @@
+import type SheetObject from '@tomorrowevening/theatre-core/sheetObjects/SheetObject';
+import type { IContextMenuItem } from '@tomorrowevening/theatre-studio/uiComponents/simpleContextMenu/useContextMenu';
+import type { SerializablePrimitive } from '@tomorrowevening/theatre-shared/utils/types';
+import type { Pointer } from '@tomorrowevening/theatre-dataverse';
+import React from 'react';
+import type { PropTypeConfig_Compound } from '@tomorrowevening/theatre-core/propTypes';
+interface CommonStuff {
+    beingScrubbed: boolean;
+    contextMenuItems: Array<IContextMenuItem>;
+    controlIndicators: React.ReactElement;
+}
+/**
+ * For compounds that have _no_ sequenced track in all of their descendants
+ */
+interface AllStatic extends CommonStuff {
+    type: 'AllStatic';
+}
+/**
+ * For compounds that have at least one sequenced track in their descendants
+ */
+interface HasSequences extends CommonStuff {
+    type: 'HasSequences';
+}
+type Stuff = AllStatic | HasSequences;
+export declare function useEditingToolsForCompoundProp<T extends SerializablePrimitive>(pointerToProp: Pointer<{}>, obj: SheetObject, propConfig: PropTypeConfig_Compound<{}>): Stuff;
+export {};
+//# sourceMappingURL=useEditingToolsForCompoundProp.d.ts.map

package/dist/propEditors/useEditingToolsForCompoundProp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditingToolsForCompoundProp.d.ts","sourceRoot":"","sources":["../../../../../studio/src/propEditors/useEditingToolsForCompoundProp.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,wDAAwD,CAAA;AAErF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,+EAA+E,CAAA;AAGnH,OAAO,KAAK,EAEV,qBAAqB,EACtB,MAAM,6CAA6C,CAAA;AAEpD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oCAAoC,CAAA;AAE/D,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,yCAAyC,CAAA;AAgBpF,UAAU,WAAW;IACnB,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;IACzC,iBAAiB,EAAE,KAAK,CAAC,YAAY,CAAA;CACtC;AAED;;GAEG;AACH,UAAU,SAAU,SAAQ,WAAW;IACrC,IAAI,EAAE,WAAW,CAAA;CAClB;AAED;;GAEG;AACH,UAAU,YAAa,SAAQ,WAAW;IACxC,IAAI,EAAE,cAAc,CAAA;CACrB;AAED,KAAK,KAAK,GAAG,SAAS,GAAG,YAAY,CAAA;AAErC,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,qBAAqB,EAC5E,aAAa,EAAE,OAAO,CAAC,EAAE,CAAC,EAC1B,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,uBAAuB,CAAC,EAAE,CAAC,GACtC,KAAK,CAyLP"}

package/dist/propEditors/useEditingToolsForCompoundProp.js

@@ -0,0 +1,228 @@
+import getStudio from '@tomorrowevening/theatre-studio/getStudio';
+import getDeep from '@tomorrowevening/theatre-shared/utils/getDeep';
+import { usePrism } from '@tomorrowevening/theatre-react';
+import { getPointerParts, prism, val } from '@tomorrowevening/theatre-dataverse';
+import get from 'lodash-es/get';
+import React from 'react';
+import DefaultOrStaticValueIndicator from './DefaultValueIndicator';
+import { compoundHasSimpleDescendants, isPropConfigComposite, iteratePropType, } from '@tomorrowevening/theatre-shared/propTypes/utils';
+import { createStudioSheetItemKey } from '@tomorrowevening/theatre-shared/utils/ids';
+import pointerDeep from '@tomorrowevening/theatre-shared/utils/pointerDeep';
+import NextPrevKeyframeCursors from './NextPrevKeyframeCursors';
+import { getNearbyKeyframesOfTrack } from './getNearbyKeyframesOfTrack';
+import { emptyObject } from '@tomorrowevening/theatre-shared/utils';
+export function useEditingToolsForCompoundProp(pointerToProp, obj, propConfig) {
+    const pathToProp = getPointerParts(pointerToProp).path;
+    return usePrism(() => {
+        // if the compound has no simple descendants, then there isn't much the user can do with it
+        if (!compoundHasSimpleDescendants(propConfig)) {
+            return {
+                type: 'AllStatic',
+                beingScrubbed: false,
+                contextMenuItems: [],
+                controlIndicators: (React.createElement(DefaultOrStaticValueIndicator, { hasStaticOverride: false, obj: obj, pathToProp: pathToProp, propConfig: propConfig })),
+            };
+        }
+        /**
+         * TODO This implementation is wrong because {@link stateEditors.studio.ephemeral.projects.stateByProjectId.stateBySheetId.stateByObjectKey.propsBeingScrubbed.flag}
+         * does not prune empty objects
+         */
+        const someDescendantsBeingScrubbed = !!val(get(getStudio().atomP.ephemeral.projects.stateByProjectId[obj.address.projectId].stateBySheetId[obj.address.sheetId].stateByObjectKey[obj.address.objectKey].valuesBeingScrubbed, getPointerParts(pointerToProp).path));
+        const contextMenuItems = [];
+        const common = {
+            beingScrubbed: someDescendantsBeingScrubbed,
+            contextMenuItems,
+            controlIndicators: React.createElement(React.Fragment, null),
+        };
+        const validSequencedTracks = val(obj.template.getMapOfValidSequenceTracks_forStudio());
+        const possibleSequenceTrackIds = getDeep(validSequencedTracks, pathToProp);
+        const hasOneOrMoreSequencedTracks = possibleSequenceTrackIds !== undefined &&
+            Object.keys(possibleSequenceTrackIds).length !== 0; // check if object is empty or undefined
+        const listOfDescendantTrackIds = [];
+        const allStaticOverrides = val(obj.template.getStaticButNotSequencedOverrides());
+        const staticOverrides = getDeep(allStaticOverrides ?? emptyObject, pathToProp);
+        let hasStatics = staticOverrides !== undefined;
+        if (hasOneOrMoreSequencedTracks) {
+            for (const descendant of iteratePropType(propConfig, [])) {
+                if (isPropConfigComposite(descendant.conf))
+                    continue;
+                const sequencedTrackIdBelongingToDescendant = getDeep(possibleSequenceTrackIds, descendant.path);
+                if (typeof sequencedTrackIdBelongingToDescendant !== 'string') {
+                    hasStatics = true;
+                }
+                else {
+                    listOfDescendantTrackIds.push(sequencedTrackIdBelongingToDescendant);
+                }
+            }
+        }
+        if (hasStatics || hasOneOrMoreSequencedTracks) {
+            contextMenuItems.push({
+                label: 'Reset all to default',
+                callback: () => {
+                    getStudio().transaction(({ unset }) => {
+                        unset(pointerToProp);
+                    });
+                },
+            });
+        }
+        if (hasOneOrMoreSequencedTracks) {
+            contextMenuItems.push({
+                label: 'Make all static',
+                callback: () => {
+                    getStudio().transaction(({ stateEditors }) => {
+                        for (const { path: subPath, conf } of iteratePropType(propConfig, [])) {
+                            if (isPropConfigComposite(conf))
+                                continue;
+                            const propAddress = {
+                                ...obj.address,
+                                pathToProp: [...pathToProp, ...subPath],
+                            };
+                            const pointerToSub = pointerDeep(pointerToProp, subPath);
+                            stateEditors.coreByProject.historic.sheetsById.sequence.setPrimitivePropAsStatic({
+                                ...propAddress,
+                                value: obj.getValueByPointer(pointerToSub),
+                            });
+                        }
+                    });
+                },
+            });
+        }
+        if (!hasOneOrMoreSequencedTracks ||
+            (hasOneOrMoreSequencedTracks && hasStatics)) {
+            contextMenuItems.push({
+                label: 'Sequence all',
+                callback: () => {
+                    getStudio().transaction(({ stateEditors }) => {
+                        for (const { path, conf } of iteratePropType(propConfig, pathToProp)) {
+                            if (isPropConfigComposite(conf))
+                                continue;
+                            const propAddress = { ...obj.address, pathToProp: path };
+                            stateEditors.coreByProject.historic.sheetsById.sequence.setPrimitivePropAsSequenced(propAddress, propConfig);
+                        }
+                    });
+                },
+            });
+        }
+        if (hasOneOrMoreSequencedTracks) {
+            const controlIndicators = prism.memo(`controlIndicators`, () => (React.createElement(ControlIndicators, { pointerToProp,
+                obj,
+                possibleSequenceTrackIds,
+                listOfDescendantTrackIds })), [possibleSequenceTrackIds, listOfDescendantTrackIds]);
+            const ret = {
+                ...common,
+                type: 'HasSequences',
+                controlIndicators,
+            };
+            return ret;
+        }
+        else {
+            return {
+                ...common,
+                type: 'AllStatic',
+                controlIndicators: (React.createElement(DefaultOrStaticValueIndicator, { hasStaticOverride: hasStatics, obj: obj, pathToProp: pathToProp, propConfig: propConfig })),
+            };
+        }
+    }, []);
+}
+function ControlIndicators({ pointerToProp, obj, possibleSequenceTrackIds, listOfDescendantTrackIds, }) {
+    return usePrism(() => {
+        const pathToProp = getPointerParts(pointerToProp).path;
+        const sequencePosition = val(obj.sheet.getSequence().positionPrism);
+        /*
+        2/10 perf concern:
+        When displaying a hierarchy like {props: {transform: {position: {x, y, z}}}},
+        we'd be recalculating this variable for both `position` and `transform`. While
+        we _could_ be re-using the calculation of `transform` in `position`, I think
+        it's unlikely that this optimization would matter.
+        */
+        const nearbyKeyframesInEachTrack = listOfDescendantTrackIds
+            .map((trackId) => ({
+            trackId,
+            track: val(obj.template.project.pointers.historic.sheetsById[obj.address.sheetId]
+                .sequence.tracksByObject[obj.address.objectKey].trackData[trackId]),
+        }))
+            .filter(({ track }) => !!track)
+            .map((s) => ({
+            ...s,
+            nearbies: getNearbyKeyframesOfTrack(obj, { id: s.trackId, data: s.track, sheetObject: obj }, sequencePosition),
+        }));
+        const hasCur = nearbyKeyframesInEachTrack.find(({ nearbies }) => !!nearbies.cur);
+        const allCur = nearbyKeyframesInEachTrack.every(({ nearbies }) => !!nearbies.cur);
+        const closestPrev = nearbyKeyframesInEachTrack.reduce((acc, s) => {
+            if (s.nearbies.prev) {
+                if (acc === undefined ||
+                    s.nearbies.prev.kf.position > acc.kf.position) {
+                    return s.nearbies.prev;
+                }
+                else {
+                    return acc;
+                }
+            }
+            else {
+                return acc;
+            }
+        }, undefined);
+        const closestNext = nearbyKeyframesInEachTrack.reduce((acc, s) => {
+            if (s.nearbies.next) {
+                if (acc === undefined ||
+                    s.nearbies.next.kf.position < acc.kf.position) {
+                    return s.nearbies.next;
+                }
+                else {
+                    return acc;
+                }
+            }
+            else {
+                return acc;
+            }
+        }, undefined);
+        const toggle = () => {
+            if (allCur) {
+                getStudio().transaction((api) => {
+                    api.unset(pointerToProp);
+                });
+            }
+            else if (hasCur) {
+                getStudio().transaction((api) => {
+                    api.set(pointerToProp, val(pointerToProp));
+                });
+            }
+            else {
+                getStudio().transaction((api) => {
+                    api.set(pointerToProp, val(pointerToProp));
+                });
+            }
+        };
+        const pr = {
+            cur: hasCur
+                ? {
+                    type: 'on',
+                    itemKey: createStudioSheetItemKey.forCompoundPropAggregateKeyframe(obj, pathToProp, sequencePosition),
+                    toggle,
+                }
+                : {
+                    toggle,
+                    type: 'off',
+                },
+            prev: closestPrev !== undefined
+                ? {
+                    position: closestPrev.kf.position,
+                    itemKey: createStudioSheetItemKey.forCompoundPropAggregateKeyframe(obj, pathToProp, closestPrev.kf.position),
+                    jump: () => {
+                        obj.sheet.getSequence().position = closestPrev.kf.position;
+                    },
+                }
+                : undefined,
+            next: closestNext !== undefined
+                ? {
+                    position: closestNext.kf.position,
+                    itemKey: createStudioSheetItemKey.forCompoundPropAggregateKeyframe(obj, pathToProp, closestNext.kf.position),
+                    jump: () => {
+                        obj.sheet.getSequence().position = closestNext.kf.position;
+                    },
+                }
+                : undefined,
+        };
+        return React.createElement(NextPrevKeyframeCursors, { ...pr });
+    }, [pointerToProp, obj, possibleSequenceTrackIds, listOfDescendantTrackIds]);
+}

package/dist/propEditors/useEditingToolsForSimpleProp.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { Pointer } from '@tomorrowevening/theatre-dataverse';
+import type SheetObject from '@tomorrowevening/theatre-core/sheetObjects/SheetObject';
+import type { IContextMenuItem } from '@tomorrowevening/theatre-studio/uiComponents/simpleContextMenu/useContextMenu';
+import type { SerializablePrimitive as SerializablePrimitive } from '@tomorrowevening/theatre-shared/utils/types';
+import type { PropTypeConfig_AllSimples } from '@tomorrowevening/theatre-core/propTypes';
+import type { NearbyKeyframes } from './getNearbyKeyframesOfTrack';
+import type { Asset, File as AssetFile } from '@tomorrowevening/theatre-shared/utils/assets';
+interface EditingToolsCommon<T> {
+    value: T;
+    beingScrubbed: boolean;
+    contextMenuItems: Array<IContextMenuItem>;
+    /** e.g. `< • >` or `<   >` for {@link EditingToolsSequenced} */
+    controlIndicators: React.ReactElement;
+    temporarilySetValue(v: T): void;
+    discardTemporaryValue(): void;
+    permanentlySetValue(v: T): void;
+    getAssetUrl: (asset: Asset | AssetFile) => string | undefined;
+    createAsset(asset: File): Promise<string | null>;
+}
+interface EditingToolsDefault<T> extends EditingToolsCommon<T> {
+    type: 'Default';
+    shade: Shade;
+}
+interface EditingToolsStatic<T> extends EditingToolsCommon<T> {
+    type: 'Static';
+    shade: Shade;
+}
+interface EditingToolsSequenced<T> extends EditingToolsCommon<T> {
+    type: 'Sequenced';
+    shade: Shade;
+    /** based on the position of the playhead */
+    nearbyKeyframes: NearbyKeyframes;
+}
+type EditingTools<T> = EditingToolsDefault<T> | EditingToolsStatic<T> | EditingToolsSequenced<T>;
+/**
+ * Notably, this uses the {@link Scrub} API to support
+ * indicating in the UI which pointers (values/props) are being
+ * scrubbed. See how impl of {@link Scrub} manages
+ * `state.flagsTransaction` to keep a list of these touched paths
+ * for the UI to be able to recognize. (e.g. to highlight the
+ * item in r3f as you change its scale).
+ */
+export declare function useEditingToolsForSimplePropInDetailsPanel<T extends SerializablePrimitive>(pointerToProp: Pointer<T>, obj: SheetObject, propConfig: PropTypeConfig_AllSimples): EditingTools<T>;
+type Shade = 'Default' | 'Static' | 'Static_BeingScrubbed' | 'Sequenced_OnKeyframe' | 'Sequenced_OnKeyframe_BeingScrubbed' | 'Sequenced_BeingInterpolated' | 'Sequened_NotBeingInterpolated';
+export {};
+//# sourceMappingURL=useEditingToolsForSimpleProp.d.ts.map

package/dist/propEditors/useEditingToolsForSimpleProp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditingToolsForSimpleProp.d.ts","sourceRoot":"","sources":["../../../../../studio/src/propEditors/useEditingToolsForSimpleProp.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,KAAK,EAAQ,OAAO,EAAC,MAAM,oCAAoC,CAAA;AAEtE,OAAO,KAAK,WAAW,MAAM,wDAAwD,CAAA;AAGrF,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,+EAA+E,CAAA;AAGnH,OAAO,KAAK,EAEV,qBAAqB,IAAI,qBAAqB,EAC/C,MAAM,6CAA6C,CAAA;AACpD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAA;AAItF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAA;AAIhE,OAAO,KAAK,EAAC,KAAK,EAAE,IAAI,IAAI,SAAS,EAAC,MAAM,8CAA8C,CAAA;AAE1F,UAAU,kBAAkB,CAAC,CAAC;IAC5B,KAAK,EAAE,CAAC,CAAA;IACR,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;IACzC,gEAAgE;IAChE,iBAAiB,EAAE,KAAK,CAAC,YAAY,CAAA;IAErC,mBAAmB,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;IAC/B,qBAAqB,IAAI,IAAI,CAAA;IAC7B,mBAAmB,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;IAE/B,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAAA;IAC7D,WAAW,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CACjD;AAED,UAAU,mBAAmB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC5D,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,KAAK,CAAA;CACb;AAED,UAAU,kBAAkB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC3D,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,KAAK,CAAA;CACb;AAED,UAAU,qBAAqB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC9D,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,KAAK,CAAA;IACZ,4CAA4C;IAC5C,eAAe,EAAE,eAAe,CAAA;CACjC;AAED,KAAK,YAAY,CAAC,CAAC,IACf,mBAAmB,CAAC,CAAC,CAAC,GACtB,kBAAkB,CAAC,CAAC,CAAC,GACrB,qBAAqB,CAAC,CAAC,CAAC,CAAA;AAuS5B;;;;;;;GAOG;AACH,wBAAgB,0CAA0C,CACxD,CAAC,SAAS,qBAAqB,EAE/B,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,EACzB,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,yBAAyB,GACpC,YAAY,CAAC,CAAC,CAAC,CAGjB;AAED,KAAK,KAAK,GACN,SAAS,GACT,QAAQ,GACR,sBAAsB,GACtB,sBAAsB,GACtB,oCAAoC,GACpC,6BAA6B,GAC7B,+BAA+B,CAAA"}