@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/StudioStore/createTransactionPrivateApi.js

@@ -0,0 +1,204 @@
+import { isSequence, isSheetObject } from '@tomorrowevening/theatre-shared/instanceTypes';
+import get from 'lodash-es/get';
+import isInteger from 'lodash-es/isInteger';
+import forEachPropDeep from '@tomorrowevening/theatre-shared/utils/forEachDeep';
+import getDeep from '@tomorrowevening/theatre-shared/utils/getDeep';
+import { getPointerParts } from '@tomorrowevening/theatre-dataverse';
+import { getPropConfigByPath } from '@tomorrowevening/theatre-shared/propTypes/utils';
+import { isPlainObject } from 'lodash-es';
+import userReadableTypeOfValue from '@tomorrowevening/theatre-shared/utils/userReadableTypeOfValue';
+/**
+ * Deep-clones a plain JS object or a `string | number | boolean`. In case of a plain
+ * object, all its sub-props that aren't `string | number | boolean` get pruned. Also,
+ * all empty objects (i.e. `{}`) get pruned.
+ *
+ * This is only used by {@link ITransactionPrivateApi.set} and it follows the global rule
+ * that values pointed to by `object.props[...]` are never `null | undefined` or an empty object.
+ */
+function cloneDeepSerializableAndPrune(v) {
+    if (typeof v === 'boolean' ||
+        typeof v === 'string' ||
+        typeof v === 'number') {
+        return v;
+    }
+    else if (isPlainObject(v)) {
+        const cloned = {};
+        let clonedAtLeastOneProp = false;
+        for (const [key, val] of Object.entries(v)) {
+            const clonedVal = cloneDeepSerializableAndPrune(val);
+            if (clonedVal !== undefined) {
+                cloned[key] = val;
+                clonedAtLeastOneProp = true;
+            }
+        }
+        if (clonedAtLeastOneProp) {
+            return cloned;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * TODO replace with {@link iteratePropType}
+ */
+function forEachDeepSimplePropOfCompoundProp(propType, path, callback) {
+    for (const [key, subType] of Object.entries(propType.props)) {
+        if (subType.type === 'compound') {
+            forEachDeepSimplePropOfCompoundProp(subType, [...path, key], callback);
+        }
+        else if (subType.type === 'enum') {
+            throw new Error(`Not yet implemented`);
+        }
+        else {
+            callback(subType, [...path, key]);
+        }
+    }
+}
+export default function createTransactionPrivateApi(ensureRunning, stateEditors, drafts) {
+    return {
+        set: (pointer, value) => {
+            ensureRunning();
+            const _value = cloneDeepSerializableAndPrune(value);
+            if (typeof _value === 'undefined')
+                return;
+            const { root, path } = getPointerParts(pointer);
+            if (isSheetObject(root)) {
+                const sequenceTracksTree = root.template
+                    .getMapOfValidSequenceTracks_forStudio()
+                    .getValue();
+                const propConfig = getPropConfigByPath(root.template.staticConfig, path);
+                if (!propConfig) {
+                    throw new Error(`Object ${root.address.objectKey} does not have a prop at ${JSON.stringify(path)}`);
+                }
+                // if (isPropConfigComposite(propConfig)) {
+                //   propConfig.validate(_value)
+                // } else {
+                //   propConfig.validate(_value)
+                // }
+                const setStaticOrKeyframeProp = (value, propConfig, path) => {
+                    if (value === undefined || value === null) {
+                        return;
+                    }
+                    const deserialized = cloneDeepSerializableAndPrune(propConfig.deserializeAndSanitize(value));
+                    if (deserialized === undefined) {
+                        throw new Error(`Invalid value ${userReadableTypeOfValue(value)} for object.props${path
+                            .map((key) => `[${JSON.stringify(key)}]`)
+                            .join('')} is invalid`);
+                    }
+                    const propAddress = { ...root.address, pathToProp: path };
+                    const trackId = get(sequenceTracksTree, path);
+                    if (typeof trackId === 'string') {
+                        const seq = root.sheet.getSequence();
+                        seq.position = seq.closestGridPosition(seq.position);
+                        stateEditors.coreByProject.historic.sheetsById.sequence.setKeyframeAtPosition({
+                            ...propAddress,
+                            trackId,
+                            position: seq.position,
+                            value: value,
+                            snappingFunction: seq.closestGridPosition,
+                            type: 'bezier',
+                        });
+                    }
+                    else {
+                        stateEditors.coreByProject.historic.sheetsById.staticOverrides.byObject.setValueOfPrimitiveProp({ ...propAddress, value: value });
+                    }
+                };
+                if (propConfig.type === 'compound') {
+                    const pathToTopPointer = getPointerParts(pointer).path;
+                    const lengthOfTopPointer = pathToTopPointer.length;
+                    // If we are dealing with a compound prop, we recurse through its
+                    // nested properties.
+                    forEachDeepSimplePropOfCompoundProp(propConfig, pathToTopPointer, (primitivePropConfig, pathToProp) => {
+                        const pathToPropInProvidedValue = pathToProp.slice(lengthOfTopPointer);
+                        const v = getDeep(_value, pathToPropInProvidedValue);
+                        if (typeof v !== 'undefined') {
+                            setStaticOrKeyframeProp(v, primitivePropConfig, pathToProp);
+                        }
+                        else {
+                            throw new Error(`Property object.props${pathToProp
+                                .map((key) => `[${JSON.stringify(key)}]`)
+                                .join('')} is required but not provided`);
+                        }
+                    });
+                }
+                else if (propConfig.type === 'enum') {
+                    throw new Error(`Enums aren't implemented yet`);
+                }
+                else {
+                    setStaticOrKeyframeProp(_value, propConfig, path);
+                }
+            }
+            else if (isSequence(root)) {
+                const [prop] = path;
+                if (prop === 'subUnitsPerUnit') {
+                    if (typeof _value !== 'number' || !isInteger(_value) || _value < 1) {
+                        throw new Error(`Value ${_value} is not an integer, which is required for setting sequence prop ${prop}`);
+                    }
+                    stateEditors.coreByProject.historic.sheetsById.sequence.setSubUnitsPerUnit({
+                        ...root.address,
+                        subUnitsPerUnit: _value,
+                    });
+                }
+                else if (prop === 'length') {
+                    if (typeof _value !== 'number' || _value <= 0.001) {
+                        throw new Error(`Value ${_value} is not a positive number, which is required for setting sequence prop ${prop}`);
+                    }
+                    stateEditors.coreByProject.historic.sheetsById.sequence.setLength({
+                        ...root.address,
+                        length: _value,
+                    });
+                }
+                else {
+                    throw new Error(`Setting sequence prop ${prop} is not supported`);
+                }
+            }
+            else {
+                throw new Error('Only setting props of SheetObject-s and sequences is supported in a transaction so far');
+            }
+        },
+        unset: (pointer) => {
+            ensureRunning();
+            const { root, path } = getPointerParts(pointer);
+            if (isSheetObject(root)) {
+                const sequenceTracksTree = root.template
+                    .getMapOfValidSequenceTracks_forStudio()
+                    .getValue();
+                const defaultValue = getDeep(root.template.getDefaultValues().getValue(), path);
+                const propConfig = getPropConfigByPath(root.template.staticConfig, path);
+                const unsetStaticOrKeyframeProp = (value, path) => {
+                    const propAddress = { ...root.address, pathToProp: path };
+                    const trackId = get(sequenceTracksTree, path);
+                    if (typeof trackId === 'string') {
+                        stateEditors.coreByProject.historic.sheetsById.sequence.unsetKeyframeAtPosition({
+                            ...propAddress,
+                            trackId,
+                            position: root.sheet.getSequence().positionSnappedToGrid,
+                        });
+                    }
+                    else if (propConfig !== undefined) {
+                        stateEditors.coreByProject.historic.sheetsById.staticOverrides.byObject.unsetValueOfPrimitiveProp(propAddress);
+                    }
+                };
+                if (propConfig.type === 'compound') {
+                    forEachPropDeep(defaultValue, (v, pathToProp) => {
+                        unsetStaticOrKeyframeProp(v, pathToProp);
+                    }, getPointerParts(pointer).path);
+                }
+                else {
+                    unsetStaticOrKeyframeProp(defaultValue, path);
+                }
+            }
+            else {
+                throw new Error('Only setting props of SheetObject-s is supported in a transaction so far');
+            }
+        },
+        get drafts() {
+            ensureRunning();
+            return drafts;
+        },
+        get stateEditors() {
+            return stateEditors;
+        },
+    };
+}

package/dist/StudioStore/generateDiskStateRevision.d.ts

@@ -0,0 +1,2 @@
+export declare function generateDiskStateRevision(): string;
+//# sourceMappingURL=generateDiskStateRevision.d.ts.map

package/dist/StudioStore/generateDiskStateRevision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDiskStateRevision.d.ts","sourceRoot":"","sources":["../../../../../studio/src/StudioStore/generateDiskStateRevision.ts"],"names":[],"mappings":"AAEA,wBAAgB,yBAAyB,WAExC"}

package/dist/StudioStore/generateDiskStateRevision.js

@@ -0,0 +1,4 @@
+import { nanoid } from 'nanoid';
+export function generateDiskStateRevision() {
+    return nanoid(16);
+}

package/dist/StudioStore/persistStateOfStudio.d.ts

@@ -0,0 +1,5 @@
+import type { FullStudioState } from '@tomorrowevening/theatre-studio/store/index';
+import type { Store } from 'redux';
+export declare const persistStateOfStudio: (reduxStore: Store<FullStudioState>, onInitialize: () => void, localStoragePrefix: string) => void;
+export declare const __experimental_clearPersistentStorage: (reduxStore: Store<FullStudioState>, localStoragePrefix: string) => void;
+//# sourceMappingURL=persistStateOfStudio.d.ts.map

package/dist/StudioStore/persistStateOfStudio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistStateOfStudio.d.ts","sourceRoot":"","sources":["../../../../../studio/src/StudioStore/persistStateOfStudio.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,6CAA6C,CAAA;AAEhF,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,OAAO,CAAA;AAOhC,eAAO,MAAM,oBAAoB,eACnB,MAAM,eAAe,CAAC,gBACpB,MAAM,IAAI,sBACJ,MAAM,SA6C3B,CAAA;AAED,eAAO,MAAM,qCAAqC,eACpC,MAAM,eAAe,CAAC,sBACd,MAAM,SAW3B,CAAA"}

package/dist/StudioStore/persistStateOfStudio.js

@@ -0,0 +1,61 @@
+import logger from '@tomorrowevening/theatre-shared/logger';
+import { studioActions } from '@tomorrowevening/theatre-studio/store';
+import debounce from 'lodash-es/debounce';
+const lastStateByStore = new WeakMap();
+export const persistStateOfStudio = (reduxStore, onInitialize, localStoragePrefix) => {
+    const loadState = (s) => {
+        reduxStore.dispatch(studioActions.replacePersistentState(s));
+    };
+    const storageKey = getStorageKey(localStoragePrefix);
+    const getState = () => reduxStore.getState().$persistent;
+    loadFromPersistentStorage();
+    const persist = () => {
+        const newState = getState();
+        const lastState = lastStateByStore.get(reduxStore);
+        if (newState === lastState)
+            return;
+        lastStateByStore.set(reduxStore, newState);
+        localStorage.setItem(storageKey, JSON.stringify(newState));
+    };
+    reduxStore.subscribe(debounce(persist, 1000));
+    if (window) {
+        window.addEventListener('beforeunload', persist);
+    }
+    function loadFromPersistentStorage() {
+        const persistedS = localStorage.getItem(storageKey);
+        if (persistedS) {
+            let persistedObj;
+            let errored = true;
+            try {
+                persistedObj = JSON.parse(persistedS);
+                errored = false;
+            }
+            catch (e) {
+                logger.warn(`Could not parse Theatre's persisted state. This must be a bug. Please report it.`);
+            }
+            finally {
+                if (!errored) {
+                    loadState(persistedObj);
+                }
+                onInitialize();
+            }
+        }
+        else {
+            onInitialize();
+        }
+    }
+};
+export const __experimental_clearPersistentStorage = (reduxStore, localStoragePrefix) => {
+    // This removes the persisted state from localStorage,
+    // while also preventing the current state from being persisted on window unload.
+    // Once the new storage PR lands, this method won't be needed anymore.
+    const storageKey = getStorageKey(localStoragePrefix);
+    const currentState = reduxStore.getState().$persistent;
+    localStorage.removeItem(storageKey);
+    // prevent the current state from being persistent on window unload,
+    // unless further state changes are made.
+    lastStateByStore.set(reduxStore, currentState);
+};
+function getStorageKey(localStoragePrefix) {
+    return localStoragePrefix + '.persistent';
+}