@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/propEditors/useEditingToolsForSimpleProp.js

@@ -0,0 +1,229 @@
+import get from 'lodash-es/get';
+import React from 'react';
+import { getPointerParts, prism, val } from '@tomorrowevening/theatre-dataverse';
+import getStudio from '@tomorrowevening/theatre-studio/getStudio';
+import getDeep from '@tomorrowevening/theatre-shared/utils/getDeep';
+import { usePrismInstance } from '@tomorrowevening/theatre-react';
+import { isPropConfSequencable } from '@tomorrowevening/theatre-shared/propTypes/utils';
+import DefaultOrStaticValueIndicator from './DefaultValueIndicator';
+import { getNearbyKeyframesOfTrack } from './getNearbyKeyframesOfTrack';
+import NextPrevKeyframeCursors from './NextPrevKeyframeCursors';
+const cache = new WeakMap();
+/**
+ * Note: we're able to get `obj` and `propConfig` from `pointerToProp`,
+ * so the only reason they're still in the arguments list is that
+ */
+function createPrism(pointerToProp, obj, propConfig) {
+    return prism(() => {
+        const pathToProp = getPointerParts(pointerToProp).path;
+        const final = obj.getValueByPointer(pointerToProp);
+        const editPropValue = prism.memo('editPropValue', () => {
+            let currentScrub = null;
+            return {
+                temporarilySetValue(v) {
+                    if (!currentScrub) {
+                        currentScrub = getStudio().scrub();
+                    }
+                    currentScrub.capture((api) => {
+                        api.set(pointerToProp, v);
+                    });
+                },
+                discardTemporaryValue() {
+                    if (currentScrub) {
+                        currentScrub.discard();
+                        currentScrub = null;
+                    }
+                },
+                permanentlySetValue(v) {
+                    if (currentScrub) {
+                        currentScrub.capture((api) => {
+                            api.set(pointerToProp, v);
+                        });
+                        currentScrub.commit();
+                        currentScrub = null;
+                    }
+                    else {
+                        getStudio().transaction((api) => {
+                            api.set(pointerToProp, v);
+                        });
+                    }
+                },
+            };
+        }, []);
+        const editAssets = {
+            createAsset: (asset) => obj.sheet.project.assetStorage.createAsset(asset),
+            getAssetUrl: (asset) => asset.id
+                ? obj.sheet.project.assetStorage.getAssetUrl(asset.id)
+                : undefined,
+        };
+        const beingScrubbed = val(get(getStudio().atomP.ephemeral.projects.stateByProjectId[obj.address.projectId].stateBySheetId[obj.address.sheetId].stateByObjectKey[obj.address.objectKey].valuesBeingScrubbed, getPointerParts(pointerToProp).path)) === true;
+        const contextMenuItems = [];
+        const common = {
+            ...editPropValue,
+            ...editAssets,
+            value: final,
+            beingScrubbed,
+            contextMenuItems,
+            controlIndicators: React.createElement(React.Fragment, null),
+        };
+        const isSequencable = isPropConfSequencable(propConfig);
+        if (isSequencable) {
+            const validSequencedTracks = val(obj.template.getMapOfValidSequenceTracks_forStudio());
+            const possibleSequenceTrackId = getDeep(validSequencedTracks, pathToProp);
+            const isSequenced = typeof possibleSequenceTrackId === 'string';
+            if (isSequenced) {
+                contextMenuItems.push({
+                    label: 'Make static',
+                    callback: () => {
+                        getStudio().transaction(({ stateEditors }) => {
+                            const propAddress = { ...obj.address, pathToProp };
+                            stateEditors.coreByProject.historic.sheetsById.sequence.setPrimitivePropAsStatic({
+                                ...propAddress,
+                                value: obj.getValueByPointer(pointerToProp),
+                            });
+                        });
+                    },
+                });
+                const sequenceTrackId = possibleSequenceTrackId;
+                const nearbyKeyframes = prism.sub('lcr', () => {
+                    const track = val(obj.template.project.pointers.historic.sheetsById[obj.address.sheetId].sequence.tracksByObject[obj.address.objectKey].trackData[sequenceTrackId]);
+                    const sequencePosition = val(obj.sheet.getSequence().positionPrism);
+                    return getNearbyKeyframesOfTrack(obj, track && {
+                        data: track,
+                        id: sequenceTrackId,
+                        sheetObject: obj,
+                    }, sequencePosition);
+                }, [sequenceTrackId]);
+                let shade;
+                if (common.beingScrubbed) {
+                    shade = 'Sequenced_OnKeyframe_BeingScrubbed';
+                }
+                else {
+                    if (nearbyKeyframes.cur) {
+                        shade = 'Sequenced_OnKeyframe';
+                    }
+                    else if (nearbyKeyframes.prev?.kf.connectedRight === true) {
+                        shade = 'Sequenced_BeingInterpolated';
+                    }
+                    else {
+                        shade = 'Sequened_NotBeingInterpolated';
+                    }
+                }
+                const toggle = () => {
+                    if (nearbyKeyframes.cur) {
+                        getStudio().transaction((api) => {
+                            api.unset(pointerToProp);
+                        });
+                    }
+                    else {
+                        getStudio().transaction((api) => {
+                            api.set(pointerToProp, common.value);
+                        });
+                    }
+                };
+                const controls = {
+                    cur: nearbyKeyframes.cur
+                        ? {
+                            type: 'on',
+                            itemKey: nearbyKeyframes.cur.itemKey,
+                            toggle,
+                        }
+                        : {
+                            type: 'off',
+                            toggle,
+                        },
+                    prev: nearbyKeyframes.prev !== undefined
+                        ? {
+                            itemKey: nearbyKeyframes.prev.itemKey,
+                            position: nearbyKeyframes.prev.kf.position,
+                            jump: () => {
+                                obj.sheet.getSequence().position =
+                                    nearbyKeyframes.prev.kf.position;
+                            },
+                        }
+                        : undefined,
+                    next: nearbyKeyframes.next !== undefined
+                        ? {
+                            itemKey: nearbyKeyframes.next.itemKey,
+                            position: nearbyKeyframes.next.kf.position,
+                            jump: () => {
+                                obj.sheet.getSequence().position =
+                                    nearbyKeyframes.next.kf.position;
+                            },
+                        }
+                        : undefined,
+                };
+                const nextPrevKeyframeCursors = (React.createElement(NextPrevKeyframeCursors, { ...controls }));
+                const ret = {
+                    ...common,
+                    type: 'Sequenced',
+                    shade,
+                    nearbyKeyframes,
+                    controlIndicators: nextPrevKeyframeCursors,
+                };
+                return ret;
+            }
+        }
+        const allStaticOverrides = val(obj.template.getStaticValues());
+        const staticOverride = getDeep(allStaticOverrides, pathToProp);
+        if (typeof staticOverride !== 'undefined') {
+            contextMenuItems.push({
+                label: 'Reset to default',
+                callback: () => {
+                    getStudio().transaction(({ unset: unset }) => {
+                        unset(pointerToProp);
+                    });
+                },
+            });
+        }
+        if (isSequencable) {
+            contextMenuItems.push({
+                label: 'Sequence',
+                callback: () => {
+                    getStudio().transaction(({ stateEditors }) => {
+                        const propAddress = { ...obj.address, pathToProp };
+                        stateEditors.coreByProject.historic.sheetsById.sequence.setPrimitivePropAsSequenced(propAddress, propConfig);
+                    });
+                },
+            });
+        }
+        if (typeof staticOverride !== 'undefined') {
+            const ret = {
+                ...common,
+                type: 'Static',
+                shade: common.beingScrubbed ? 'Static_BeingScrubbed' : 'Static',
+                controlIndicators: (React.createElement(DefaultOrStaticValueIndicator, { hasStaticOverride: true, obj: obj, pathToProp: pathToProp, propConfig: propConfig })),
+            };
+            return ret;
+        }
+        const ret = {
+            ...common,
+            type: 'Default',
+            shade: 'Default',
+            controlIndicators: (React.createElement(DefaultOrStaticValueIndicator, { hasStaticOverride: true, obj: obj, pathToProp: pathToProp, propConfig: propConfig })),
+        };
+        return ret;
+    });
+}
+function getPrism(pointerToProp, obj, propConfig) {
+    if (cache.has(pointerToProp)) {
+        return cache.get(pointerToProp);
+    }
+    else {
+        const d = createPrism(pointerToProp, obj, propConfig);
+        cache.set(pointerToProp, d);
+        return d;
+    }
+}
+/**
+ * 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 function useEditingToolsForSimplePropInDetailsPanel(pointerToProp, obj, propConfig) {
+    const der = getPrism(pointerToProp, obj, propConfig);
+    return usePrismInstance(der);
+}

package/dist/propEditors/utils/IEditingTools.d.ts

@@ -0,0 +1,9 @@
+import type { Asset, File } from '@tomorrowevening/theatre-shared/utils/assets';
+export interface IEditingTools<T> {
+    temporarilySetValue(v: T): void;
+    discardTemporaryValue(): void;
+    permanentlySetValue(v: T): void;
+    getAssetUrl(asset: Asset | File): string | undefined;
+    createAsset(asset: Blob): Promise<string | null>;
+}
+//# sourceMappingURL=IEditingTools.d.ts.map

package/dist/propEditors/utils/IEditingTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IEditingTools.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/utils/IEditingTools.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,KAAK,EAAE,IAAI,EAAC,MAAM,8CAA8C,CAAA;AAE7E,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,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,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAAA;IACpD,WAAW,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CACjD"}

package/dist/propEditors/utils/IEditingTools.js

@@ -0,0 +1 @@
+export {};

package/dist/propEditors/utils/PropConfigForType.d.ts

@@ -0,0 +1,5 @@
+import type { PropTypeConfig } from '@tomorrowevening/theatre-core/propTypes';
+export type PropConfigForType<K extends PropTypeConfig['type']> = Extract<PropTypeConfig, {
+    type: K;
+}>;
+//# sourceMappingURL=PropConfigForType.d.ts.map

package/dist/propEditors/utils/PropConfigForType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropConfigForType.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/utils/PropConfigForType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yCAAyC,CAAA;AAE3E,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,IAAI,OAAO,CACvE,cAAc,EACd;IAAC,IAAI,EAAE,CAAC,CAAA;CAAC,CACV,CAAA"}

package/dist/propEditors/utils/PropConfigForType.js

@@ -0,0 +1 @@
+export {};

package/dist/propEditors/utils/getPropTypeByPointer.d.ts

@@ -0,0 +1,19 @@
+import type { PropTypeConfig } from '@tomorrowevening/theatre-core/propTypes';
+import type SheetObject from '@tomorrowevening/theatre-core/sheetObjects/SheetObject';
+/**
+ * @deprecated because it uses obj.template.staticConfig
+ *
+ * Returns the PropTypeConfig by path. Assumes `path` is a valid prop path and that
+ * it exists in obj.
+ *
+ * Example usage:
+ * ```
+ * const propConfig = getPropTypeByPointer(propP, sheetObject)
+ *
+ * if (propConfig.type === 'number') {
+ * //... etc.
+ * }
+ * ```
+ */
+export declare function getPropTypeByPointer(pointerToProp: SheetObject['propsP'], obj: SheetObject): PropTypeConfig;
+//# sourceMappingURL=getPropTypeByPointer.d.ts.map

package/dist/propEditors/utils/getPropTypeByPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPropTypeByPointer.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/utils/getPropTypeByPointer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yCAAyC,CAAA;AAC3E,OAAO,KAAK,WAAW,MAAM,wDAAwD,CAAA;AAGrF;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,WAAW,CAAC,QAAQ,CAAC,EACpC,GAAG,EAAE,WAAW,GACf,cAAc,CAsChB"}

package/dist/propEditors/utils/getPropTypeByPointer.js

@@ -0,0 +1,48 @@
+import { getPointerParts } from '@tomorrowevening/theatre-dataverse';
+/**
+ * @deprecated because it uses obj.template.staticConfig
+ *
+ * Returns the PropTypeConfig by path. Assumes `path` is a valid prop path and that
+ * it exists in obj.
+ *
+ * Example usage:
+ * ```
+ * const propConfig = getPropTypeByPointer(propP, sheetObject)
+ *
+ * if (propConfig.type === 'number') {
+ * //... etc.
+ * }
+ * ```
+ */
+export function getPropTypeByPointer(pointerToProp, obj) {
+    const rootConf = obj.template.staticConfig;
+    const p = getPointerParts(pointerToProp).path;
+    let conf = rootConf;
+    while (p.length !== 0) {
+        const key = p.shift();
+        if (typeof key === 'string') {
+            if (conf.type === 'compound') {
+                conf = conf.props[key];
+                if (!conf) {
+                    throw new Error(`getPropTypeConfigByPath() is called with an invalid path.`);
+                }
+            }
+            else if (conf.type === 'enum') {
+                conf = conf.cases[key];
+                if (!conf) {
+                    throw new Error(`getPropTypeConfigByPath() is called with an invalid path.`);
+                }
+            }
+            else {
+                throw new Error(`getPropTypeConfigByPath() is called with an invalid path.`);
+            }
+        }
+        else if (typeof key === 'number') {
+            throw new Error(`Number indexes are not implemented yet. @todo`);
+        }
+        else {
+            throw new Error(`getPropTypeConfigByPath() is called with an invalid path.`);
+        }
+    }
+    return conf;
+}

package/dist/propEditors/utils/propNameTextCSS.d.ts

@@ -0,0 +1,5 @@
+import type { PropHighlighted } from '@tomorrowevening/theatre-studio/panels/SequenceEditorPanel/whatPropIsHighlighted';
+export declare const propNameTextCSS: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<{
+    isHighlighted?: PropHighlighted | undefined;
+}, any>>;
+//# sourceMappingURL=propNameTextCSS.d.ts.map

package/dist/propEditors/utils/propNameTextCSS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propNameTextCSS.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/propEditors/utils/propNameTextCSS.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,kFAAkF,CAAA;AAGrH,eAAO,MAAM,eAAe;;QAK3B,CAAA"}

package/dist/propEditors/utils/propNameTextCSS.js

@@ -0,0 +1,7 @@
+import { css } from 'styled-components';
+export const propNameTextCSS = css `
+  font-weight: 300;
+  font-size: 11px;
+  color: ${(props) => (props.isHighlighted === 'self' ? '#CCC' : '#919191')};
+  text-shadow: 0.5px 0.5px 2px rgba(0, 0, 0, 0.3);
+`;

package/dist/selectors.d.ts

@@ -0,0 +1,13 @@
+import type Project from '@tomorrowevening/theatre-core/projects/Project';
+import type Sequence from '@tomorrowevening/theatre-core/sequences/Sequence';
+import type Sheet from '@tomorrowevening/theatre-core/sheets/Sheet';
+import type { OutlineSelection } from './store/types';
+export declare const getOutlineSelection: () => OutlineSelection;
+export declare const getSelectedInstanceOfSheetId: (project: Project, selectedSheetId: string) => Sheet | undefined;
+/**
+ * component instances could come and go all the time. This hook
+ * makes sure we don't cause re-renders
+ */
+export declare function getRegisteredSheetIds(project: Project): string[];
+export declare function getSelectedSequence(): undefined | Sequence;
+//# sourceMappingURL=selectors.d.ts.map

package/dist/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../studio/src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gDAAgD,CAAA;AACzE,OAAO,KAAK,QAAQ,MAAM,kDAAkD,CAAA;AAE5E,OAAO,KAAK,KAAK,MAAM,4CAA4C,CAAA;AAOnE,OAAO,KAAK,EAAoB,gBAAgB,EAAC,MAAM,eAAe,CAAA;AAEtE,eAAO,MAAM,mBAAmB,wBA0B/B,CAAA;AAED,eAAO,MAAM,4BAA4B,YAC9B,OAAO,mBACC,MAAM,KACtB,KAAK,GAAG,SAsBV,CAAA;AAMD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEhE;AAED,wBAAgB,mBAAmB,IAAI,SAAS,GAAG,QAAQ,CAU1D"}

package/dist/selectors.js

@@ -0,0 +1,63 @@
+import { val } from '@tomorrowevening/theatre-dataverse';
+import { isSheet, isSheetObject } from '@tomorrowevening/theatre-shared/instanceTypes';
+import { uniq } from 'lodash-es';
+import getStudio from './getStudio';
+export const getOutlineSelection = () => {
+    const projects = val(getStudio().projectsP);
+    const mapped = (val(getStudio().atomP.historic.panels.outlinePanel.selection) ?? []).map((s) => {
+        const project = projects[s.projectId];
+        if (!project)
+            return;
+        if (s.type === 'Project')
+            return project;
+        const sheetTemplate = val(project.sheetTemplatesP[s.sheetId]);
+        if (!sheetTemplate) {
+            return;
+        }
+        const sheetInstance = getSelectedInstanceOfSheetId(project, s.sheetId);
+        if (!sheetInstance)
+            return;
+        if (s.type === 'Sheet') {
+            return sheetInstance;
+        }
+        const obj = val(sheetInstance.objectsP[s.objectKey]);
+        if (!obj)
+            return;
+        return obj;
+    });
+    return uniq(mapped.filter((s) => typeof s !== 'undefined'));
+};
+export const getSelectedInstanceOfSheetId = (project, selectedSheetId) => {
+    const projectStateP = getStudio().atomP.historic.projects.stateByProjectId[project.address.projectId];
+    const instanceId = val(projectStateP.stateBySheetId[selectedSheetId].selectedInstanceId);
+    const template = val(project.sheetTemplatesP[selectedSheetId]);
+    if (!template)
+        return undefined;
+    if (instanceId) {
+        return val(template.instancesP[instanceId]);
+    }
+    else {
+        // @todo #perf this will update every time an instance is added/removed.
+        const allInstances = val(template.instancesP);
+        return allInstances[keys(allInstances)[0]];
+    }
+};
+function keys(obj) {
+    return Object.keys(obj);
+}
+/**
+ * component instances could come and go all the time. This hook
+ * makes sure we don't cause re-renders
+ */
+export function getRegisteredSheetIds(project) {
+    return Object.keys(val(project.sheetTemplatesP));
+}
+export function getSelectedSequence() {
+    const selectedSheets = uniq(getOutlineSelection()
+        .filter((s) => isSheet(s) || isSheetObject(s))
+        .map((s) => (isSheetObject(s) ? s.sheet : s)));
+    const sheet = selectedSheets[0];
+    if (!sheet)
+        return;
+    return sheet.getSequence();
+}

package/dist/store/index.d.ts

@@ -0,0 +1,210 @@
+import type { StudioState } from '@tomorrowevening/theatre-studio/store/types';
+import type { IWithHistory } from '@tomorrowevening/theatre-studio/utils/redux/withHistory/withHistory';
+import type { ReduxReducer } from '@tomorrowevening/theatre-shared/utils/types';
+export type StudioPersistentState = {
+    historic: IWithHistory<StudioState['historic']>;
+    ahistoric: StudioState['ahistoric'];
+};
+export type FullStudioState = {
+    $temps: {
+        permanent: PermanentState;
+        tempActions: Array<typeof _pushTemporaryAction['ActionType']>;
+    };
+} & StudioState & {
+    $persistent: StudioPersistentState;
+};
+type PermanentState = {
+    $persistent: StudioPersistentState;
+    ephemeral: StudioState['ephemeral'];
+};
+declare const reduceParts: {
+    (input: (wholeState: StudioState) => StudioState): {
+        type: "@storeBundle/reduceParts";
+        payload: (wholeState: StudioState) => StudioState;
+    };
+    type: "@storeBundle/reduceParts";
+    ActionType: {
+        type: "@storeBundle/reduceParts";
+        payload: (wholeState: StudioState) => StudioState;
+    };
+    is: (o: any) => o is {
+        type: "@storeBundle/reduceParts";
+        payload: (wholeState: StudioState) => StudioState;
+    };
+};
+export declare const studioActions: {
+    historic: {
+        replaceHistory: {
+            <Payload>(payload: Payload): {
+                type: "@history/replaceHistory";
+                payload: Payload;
+            };
+            (): {
+                type: "@history/replaceHistory";
+                payload: void;
+            };
+            type: "@history/replaceHistory";
+            ActionType: {
+                type: "@history/replaceHistory";
+                payload: unknown;
+            };
+            is: (o: unknown) => o is {
+                type: "@history/replaceHistory";
+                payload: unknown;
+            };
+        };
+        startHistoryFromScratch: {
+            <Payload_1>(payload: Payload_1): {
+                type: "@history/startHistoryFromScratch";
+                payload: Payload_1;
+            };
+            (): {
+                type: "@history/startHistoryFromScratch";
+                payload: void;
+            };
+            type: "@history/startHistoryFromScratch";
+            ActionType: {
+                type: "@history/startHistoryFromScratch";
+                payload: unknown;
+            };
+            is: (o: unknown) => o is {
+                type: "@history/startHistoryFromScratch";
+                payload: unknown;
+            };
+        };
+        undo: {
+            <Payload_2>(payload: Payload_2): {
+                type: "@history/undo";
+                payload: Payload_2;
+            };
+            (): {
+                type: "@history/undo";
+                payload: void;
+            };
+            type: "@history/undo";
+            ActionType: {
+                type: "@history/undo";
+                payload: unknown;
+            };
+            is: (o: unknown) => o is {
+                type: "@history/undo";
+                payload: unknown;
+            };
+        };
+        redo: {
+            <Payload_3>(payload: Payload_3): {
+                type: "@history/redo";
+                payload: Payload_3;
+            };
+            (): {
+                type: "@history/redo";
+                payload: void;
+            };
+            type: "@history/redo";
+            ActionType: {
+                type: "@history/redo";
+                payload: unknown;
+            };
+            is: (o: unknown) => o is {
+                type: "@history/redo";
+                payload: unknown;
+            };
+        };
+    };
+    replacePersistentState: {
+        (input: StudioPersistentState): {
+            type: "@storeBundle/replacePersistentState";
+            payload: StudioPersistentState;
+        };
+        type: "@storeBundle/replacePersistentState";
+        ActionType: {
+            type: "@storeBundle/replacePersistentState";
+            payload: StudioPersistentState;
+        };
+        is: (o: any) => o is {
+            type: "@storeBundle/replacePersistentState";
+            payload: StudioPersistentState;
+        };
+    };
+    reduceParts: {
+        (input: (wholeState: StudioState) => StudioState): {
+            type: "@storeBundle/reduceParts";
+            payload: (wholeState: StudioState) => StudioState;
+        };
+        type: "@storeBundle/reduceParts";
+        ActionType: {
+            type: "@storeBundle/reduceParts";
+            payload: (wholeState: StudioState) => StudioState;
+        };
+        is: (o: any) => o is {
+            type: "@storeBundle/reduceParts";
+            payload: (wholeState: StudioState) => StudioState;
+        };
+    };
+};
+export declare const _pushTemporaryAction: {
+    (input: {
+        id: number;
+        originalAction: typeof reduceParts.ActionType;
+    }): {
+        type: "@history/pushTempAction";
+        payload: {
+            id: number;
+            originalAction: typeof reduceParts.ActionType;
+        };
+    };
+    type: "@history/pushTempAction";
+    ActionType: {
+        type: "@history/pushTempAction";
+        payload: {
+            id: number;
+            originalAction: typeof reduceParts.ActionType;
+        };
+    };
+    is: (o: any) => o is {
+        type: "@history/pushTempAction";
+        payload: {
+            id: number;
+            originalAction: typeof reduceParts.ActionType;
+        };
+    };
+};
+export declare const _discardTemporaryAction: {
+    (input: number): {
+        type: "@history/discardTempAction";
+        payload: number;
+    };
+    type: "@history/discardTempAction";
+    ActionType: {
+        type: "@history/discardTempAction";
+        payload: number;
+    };
+    is: (o: any) => o is {
+        type: "@history/discardTempAction";
+        payload: number;
+    };
+};
+export declare const _commitTemporaryAction: {
+    (input: number): {
+        type: "@history/commitTempAction";
+        payload: number;
+    };
+    type: "@history/commitTempAction";
+    ActionType: {
+        type: "@history/commitTempAction";
+        payload: number;
+    };
+    is: (o: any) => o is {
+        type: "@history/commitTempAction";
+        payload: number;
+    };
+};
+export interface ITempActionGroup {
+    push(originalAction: typeof reduceParts.ActionType): typeof _pushTemporaryAction.ActionType;
+    discard(): typeof _discardTemporaryAction.ActionType;
+    commit(): typeof _commitTemporaryAction.ActionType;
+}
+export declare const tempActionGroup: () => ITempActionGroup;
+export declare const studioReducer: ReduxReducer<FullStudioState>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../studio/src/store/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,6CAA6C,CAAA;AAE5E,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qEAAqE,CAAA;AAKrG,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,6CAA6C,CAAA;AAwC7E,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,YAAY,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAA;IAC/C,SAAS,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE;QACN,SAAS,EAAE,cAAc,CAAA;QACzB,WAAW,EAAE,KAAK,CAAC,OAAO,oBAAoB,CAAC,YAAY,CAAC,CAAC,CAAA;KAC9D,CAAA;CACF,GAAG,WAAW,GAAG;IAAC,WAAW,EAAE,qBAAqB,CAAA;CAAC,CAAA;AAEtD,KAAK,cAAc,GAAG;IACpB,WAAW,EAAE,qBAAqB,CAAA;IAClC,SAAS,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;CACpC,CAAA;AAOD,QAAA,MAAM,WAAW;yBAEG,WAAW,KAAK,WAAW;;8BAA3B,WAAW,KAAK,WAAW;;;;;8BAA3B,WAAW,KAAK,WAAW;;;;8BAA3B,WAAW,KAAK,WAAW;;CAC9C,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAHN,WAAW,KAAK,WAAW;;kCAA3B,WAAW,KAAK,WAAW;;;;;kCAA3B,WAAW,KAAK,WAAW;;;;kCAA3B,WAAW,KAAK,WAAW;;;CAO9C,CAAA;AAkFD,eAAO,MAAM,oBAAoB;;YAElB,MAAM;wBAAkB,OAAO,YAAY,UAAU;;;;gBAArD,MAAM;4BAAkB,OAAO,YAAY,UAAU;;;;;;;gBAArD,MAAM;4BAAkB,OAAO,YAAY,UAAU;;;;;;gBAArD,MAAM;4BAAkB,OAAO,YAAY,UAAU;;;CACnE,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;CAGnC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAGlC,CAAA;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CACF,cAAc,EAAE,OAAO,WAAW,CAAC,UAAU,GAC5C,OAAO,oBAAoB,CAAC,UAAU,CAAA;IACzC,OAAO,IAAI,OAAO,uBAAuB,CAAC,UAAU,CAAA;IACpD,MAAM,IAAI,OAAO,sBAAsB,CAAC,UAAU,CAAA;CACnD;AAID,eAAO,MAAM,eAAe,QAAO,gBAiBlC,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,eAAe,CAkEvD,CAAA"}