@tomorrowevening/theatre-studio 1.0.5 → 1.0.6

package/dist/StudioBundle.js

@@ -1,21 +0,0 @@
-export default class StudioBundle {
-    _studio;
-    _coreBundle;
-    constructor(_studio) {
-        this._studio = _studio;
-    }
-    get type() {
-        return 'Theatre_StudioBundle';
-    }
-    registerCoreBundle(coreBundle) {
-        if (this._coreBundle) {
-            throw new Error(`StudioBundle.coreBundle is already registered. This is a bug.`);
-        }
-        this._coreBundle = coreBundle;
-        let coreBits;
-        coreBundle.getBitsForStudio(this._studio, (bits) => {
-            coreBits = bits;
-        });
-        this._studio.setCoreBits(coreBits);
-    }
-}

package/dist/StudioStore/StudioStore.js

@@ -1,163 +0,0 @@
-import { studioActions, studioReducer, tempActionGroup, } from '@tomorrowevening/theatre-studio/store';
-import { setDrafts__onlyMeantToBeCalledByTransaction } from '@tomorrowevening/theatre-studio/store/stateEditors';
-import { defer } from '@tomorrowevening/theatre-shared/utils/defer';
-import atomFromReduxStore from '@tomorrowevening/theatre-studio/utils/redux/atomFromReduxStore';
-import configureStore from '@tomorrowevening/theatre-studio/utils/redux/configureStore';
-import { createDraft, finishDraft } from 'immer';
-import { __experimental_clearPersistentStorage, persistStateOfStudio, } from './persistStateOfStudio';
-import { generateDiskStateRevision } from './generateDiskStateRevision';
-import cloneDeep from 'lodash-es/cloneDeep';
-import createTransactionPrivateApi from './createTransactionPrivateApi';
-export default class StudioStore {
-    _reduxStore;
-    _atom;
-    atomP;
-    constructor() {
-        this._reduxStore = configureStore({
-            rootReducer: studioReducer,
-            devtoolsOptions: { name: 'Theatre.js Studio' },
-        });
-        this._atom = atomFromReduxStore(this._reduxStore);
-        this.atomP = this._atom.pointer;
-    }
-    initialize(opts) {
-        const d = defer();
-        if (opts.usePersistentStorage === true) {
-            persistStateOfStudio(this._reduxStore, () => {
-                this.tempTransaction(({ drafts }) => {
-                    drafts.ephemeral.initialised = true;
-                }).commit();
-                d.resolve();
-            }, opts.persistenceKey);
-        }
-        else {
-            this.tempTransaction(({ drafts }) => {
-                drafts.ephemeral.initialised = true;
-            }).commit();
-            d.resolve();
-        }
-        return d.promise;
-    }
-    getState() {
-        return this._reduxStore.getState();
-    }
-    __experimental_clearPersistentStorage(persistenceKey) {
-        __experimental_clearPersistentStorage(this._reduxStore, persistenceKey);
-        return this.getState();
-    }
-    /**
-     * This method causes the store to start the history from scratch. This is useful
-     * for testing and development where you want to explicitly provide a state to the
-     * store.
-     */
-    __dev_startHistoryFromScratch(newHistoricPart) {
-        this._reduxStore.dispatch(studioActions.historic.startHistoryFromScratch(studioActions.reduceParts((s) => ({ ...s, historic: newHistoricPart }))));
-    }
-    tempTransaction(fn) {
-        const group = tempActionGroup();
-        let errorDuringTransaction = undefined;
-        const action = group.push(studioActions.reduceParts((wholeState) => {
-            const drafts = {
-                historic: createDraft(wholeState.historic),
-                ahistoric: createDraft(wholeState.ahistoric),
-                ephemeral: createDraft(wholeState.ephemeral),
-            };
-            let running = true;
-            let ensureRunning = () => {
-                if (!running) {
-                    throw new Error(`You seem to have called the transaction api after studio.transaction() has finished running`);
-                }
-            };
-            const stateEditors = setDrafts__onlyMeantToBeCalledByTransaction(drafts);
-            const api = createTransactionPrivateApi(ensureRunning, stateEditors, drafts);
-            try {
-                fn(api);
-                running = false;
-                return {
-                    historic: finishDraft(drafts.historic),
-                    ahistoric: finishDraft(drafts.ahistoric),
-                    ephemeral: finishDraft(drafts.ephemeral),
-                };
-            }
-            catch (err) {
-                errorDuringTransaction = err;
-                return wholeState;
-            }
-            finally {
-                setDrafts__onlyMeantToBeCalledByTransaction(undefined);
-            }
-        }));
-        this._reduxStore.dispatch(action);
-        if (errorDuringTransaction) {
-            this._reduxStore.dispatch(group.discard());
-            // eslint-disable-next-line @typescript-eslint/no-throw-literal
-            throw errorDuringTransaction;
-        }
-        return {
-            commit: () => {
-                this._reduxStore.dispatch(group.commit());
-            },
-            discard: () => {
-                this._reduxStore.dispatch(group.discard());
-            },
-        };
-    }
-    undo() {
-        this._reduxStore.dispatch(studioActions.historic.undo());
-    }
-    redo() {
-        this._reduxStore.dispatch(studioActions.historic.redo());
-    }
-    createContentOfSaveFile(projectId) {
-        const projectState = this._reduxStore.getState().$persistent.historic.innerState.coreByProject[projectId];
-        if (!projectState) {
-            throw new Error(`Project ${projectId} has not been initialized.`);
-        }
-        const revision = generateDiskStateRevision();
-        this.tempTransaction(({ stateEditors }) => {
-            stateEditors.coreByProject.historic.revisionHistory.add({
-                projectId,
-                revision,
-            });
-        }).commit();
-        const projectHistoricState = this._reduxStore.getState().$persistent.historic.innerState.coreByProject[projectId];
-        const studioState = this._reduxStore.getState().$persistent.historic.innerState.projects
-            ?.stateByProjectId[projectId];
-        const generatedOnDiskState = cloneDeep(projectHistoricState);
-        // Copy markers from studio state to the exported state
-        if (studioState?.stateBySheetId) {
-            for (const [sheetId, sheetState] of Object.entries(studioState.stateBySheetId)) {
-                if (sheetState?.sequenceEditor?.markerSet) {
-                    const markerSet = sheetState.sequenceEditor.markerSet;
-                    if (markerSet.allIds && Object.keys(markerSet.allIds).length > 0) {
-                        // Ensure the sheet exists in the generated state
-                        if (!generatedOnDiskState.sheetsById[sheetId]) {
-                            generatedOnDiskState.sheetsById[sheetId] = {
-                                staticOverrides: { byObject: {} },
-                            };
-                        }
-                        const sheet = generatedOnDiskState.sheetsById[sheetId];
-                        if (sheet !== undefined) {
-                            // Ensure the sequence exists
-                            if (!sheet.sequence) {
-                                sheet.sequence = {
-                                    type: 'PositionalSequence',
-                                    length: 10,
-                                    subUnitsPerUnit: 30,
-                                    tracksByObject: {},
-                                };
-                            }
-                            // Convert PointableSet to array
-                            const markers = Object.entries(markerSet.byId)
-                                .map(([id, marker]) => marker)
-                                .filter((marker) => marker !== undefined)
-                                .sort((a, b) => a.position - b.position);
-                            sheet.sequence.markers = markers;
-                        }
-                    }
-                }
-            }
-        }
-        return generatedOnDiskState;
-    }
-}

package/dist/StudioStore/createTransactionPrivateApi.js

@@ -1,204 +0,0 @@
-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.js

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

package/dist/StudioStore/persistStateOfStudio.js

@@ -1,61 +0,0 @@
-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';
-}

package/dist/TheatreStudio.js

@@ -1,154 +0,0 @@
-import { prism } from '@tomorrowevening/theatre-dataverse';
-import SimpleCache from '@tomorrowevening/theatre-shared/utils/SimpleCache';
-import { isSheetObjectPublicAPI, isSheetPublicAPI, } from '@tomorrowevening/theatre-shared/instanceTypes';
-import { getOutlineSelection } from './selectors';
-import getStudio from './getStudio';
-import { debounce } from 'lodash-es';
-import { __experimental_disblePlayPauseKeyboardShortcut, __experimental_enablePlayPauseKeyboardShortcut, } from './UIRoot/useKeyboardShortcuts';
-export default class TheatreStudio {
-    ui = {
-        hide() {
-            getStudio().ui.hide();
-        },
-        get isHidden() {
-            return getStudio().ui.isHidden;
-        },
-        restore() {
-            getStudio().ui.restore();
-        },
-        renderToolset(toolsetId, htmlNode) {
-            return getStudio().ui.renderToolset(toolsetId, htmlNode);
-        },
-    };
-    _cache = new SimpleCache();
-    __experimental = {
-        __experimental_disblePlayPauseKeyboardShortcut() {
-            // This is an experimental API to respond to this issue: https://discord.com/channels/870988717190426644/870988717190426647/1067906775602430062
-            // Ideally we need a coherent way for the user to control keyboard inputs, so we will remove this method in the future.
-            // Here is the procedure for removing it:
-            // 1. Replace this code with a `throw new Error("This is experimental method is now deprecated, and here is how to migrate: ...")`
-            // 2. Then keep it for a few months, and then remove it.
-            __experimental_disblePlayPauseKeyboardShortcut();
-        },
-        __experimental_enablePlayPauseKeyboardShortcut() {
-            // see __experimental_disblePlayPauseKeyboardShortcut()
-            __experimental_enablePlayPauseKeyboardShortcut();
-        },
-        __experimental_clearPersistentStorage(persistenceKey) {
-            return getStudio().clearPersistentStorage(persistenceKey);
-        },
-        __experimental_createContentOfSaveFileTyped(projectId) {
-            return getStudio().createContentOfSaveFile(projectId);
-        },
-    };
-    /**
-     * @internal
-     */
-    constructor(internals) { }
-    initialize(opts) {
-        const studio = getStudio();
-        return studio.initialize(opts);
-    }
-    extend(extension, opts) {
-        getStudio().extend(extension, opts);
-    }
-    transaction(fn) {
-        return getStudio().transaction(({ set, unset, stateEditors }) => {
-            const __experimental_forgetObject = (object) => {
-                if (!isSheetObjectPublicAPI(object)) {
-                    throw new Error(`object in transactionApi.__experimental_forgetObject(object) must be the return type of sheet.object(...)`);
-                }
-                stateEditors.coreByProject.historic.sheetsById.forgetObject(object.address);
-            };
-            const __experimental_forgetSheet = (sheet) => {
-                if (!isSheetPublicAPI(sheet)) {
-                    throw new Error(`sheet in transactionApi.__experimental_forgetSheet(sheet) must be the return type of project.sheet()`);
-                }
-                stateEditors.coreByProject.historic.sheetsById.forgetSheet(sheet.address);
-            };
-            return fn({
-                set,
-                unset,
-                __experimental_forgetObject,
-                __experimental_forgetSheet,
-            });
-        });
-    }
-    _getSelectionPrism() {
-        return this._cache.get('_getSelectionPrism()', () => prism(() => {
-            return getOutlineSelection()
-                .filter((s) => s.type === 'Theatre_SheetObject' || s.type === 'Theatre_Sheet')
-                .map((s) => s.publicApi);
-        }));
-    }
-    _getSelection() {
-        return this._getSelectionPrism().getValue();
-    }
-    setSelection(selection) {
-        const sanitizedSelection = [...selection]
-            .filter((s) => isSheetObjectPublicAPI(s) || isSheetPublicAPI(s))
-            .map((s) => getStudio().corePrivateAPI(s));
-        getStudio().transaction(({ stateEditors }) => {
-            stateEditors.studio.historic.panels.outline.selection.set(sanitizedSelection);
-        });
-    }
-    onSelectionChange(fn) {
-        const studio = getStudio();
-        return this._getSelectionPrism().onChange(studio.ticker, fn, true);
-    }
-    get selection() {
-        return this._getSelection();
-    }
-    scrub() {
-        return getStudio().scrub();
-    }
-    getStudioProject() {
-        const core = getStudio().core;
-        if (!core) {
-            throw new Error(`You're calling studio.getStudioProject() before \`@tomorrowevening/theatre-core\` is loaded. To fix this:
-1. Check if \`@tomorrowevening/theatre-core\` is import/required in your bundle.
-2. Check the stack trace of this error and make sure the funciton that calls getStudioProject() is run after \`@tomorrowevening/theatre-core\` is loaded.`);
-        }
-        return getStudio().getStudioProject(core);
-    }
-    debouncedScrub(threshold = 1000) {
-        let currentScrub;
-        const scheduleCommit = debounce(() => {
-            const s = currentScrub;
-            if (!s)
-                return;
-            currentScrub = undefined;
-            s.commit();
-        }, threshold);
-        const capture = (arg) => {
-            if (!currentScrub) {
-                currentScrub = this.scrub();
-            }
-            let errored = true;
-            try {
-                currentScrub.capture(arg);
-                errored = false;
-            }
-            finally {
-                if (errored) {
-                    const s = currentScrub;
-                    currentScrub = undefined;
-                    s.discard();
-                }
-                else {
-                    scheduleCommit();
-                }
-            }
-        };
-        return { capture };
-    }
-    createPane(paneClass) {
-        return getStudio().paneManager.createPane(paneClass);
-    }
-    destroyPane(paneId) {
-        return getStudio().paneManager.destroyPane(paneId);
-    }
-    createContentOfSaveFile(projectId) {
-        return getStudio().createContentOfSaveFile(projectId);
-    }
-}

package/dist/UI/UI.js

@@ -1,65 +0,0 @@
-import { val } from '@tomorrowevening/theatre-dataverse';
-const NonSSRBitsClass = typeof window !== 'undefined'
-    ? import('./UINonSSRBits').then((M) => M.default)
-    : null;
-export default class UI {
-    studio;
-    _rendered = false;
-    _nonSSRBits = NonSSRBitsClass
-        ? NonSSRBitsClass.then((NonSSRBitsClass) => new NonSSRBitsClass())
-        : Promise.reject();
-    ready = this._nonSSRBits.then(() => undefined, () => undefined);
-    constructor(studio) {
-        this.studio = studio;
-    }
-    render() {
-        if (this._rendered) {
-            return;
-        }
-        this._rendered = true;
-        this._nonSSRBits
-            .then((b) => {
-            b.render();
-        })
-            .catch((err) => {
-            console.error(err);
-            throw err;
-        });
-    }
-    hide() {
-        this.studio.transaction(({ drafts }) => {
-            drafts.ahistoric.visibilityState = 'everythingIsHidden';
-        });
-    }
-    restore() {
-        this.render();
-        this.studio.transaction(({ drafts }) => {
-            drafts.ahistoric.visibilityState = 'everythingIsVisible';
-        });
-    }
-    get isHidden() {
-        return (val(this.studio.atomP.ahistoric.visibilityState) === 'everythingIsHidden');
-    }
-    renderToolset(toolsetId, htmlNode) {
-        let shouldUnmount = false;
-        let unmount = null;
-        this._nonSSRBits
-            .then((nonSSRBits) => {
-            if (shouldUnmount)
-                return; // unmount requested before the toolset is mounted, so, abort
-            unmount = nonSSRBits.renderToolset(toolsetId, htmlNode);
-        })
-            .catch((err) => {
-            console.error(err);
-        });
-        return () => {
-            if (unmount) {
-                unmount();
-                return;
-            }
-            if (shouldUnmount)
-                return;
-            shouldUnmount = true;
-        };
-    }
-}