@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/Studio.js

@@ -0,0 +1,405 @@
+import Scrub from '@tomorrowevening/theatre-studio/Scrub';
+import UI from '@tomorrowevening/theatre-studio/UI/UI';
+import { Atom, PointerProxy, pointerToPrism } from '@tomorrowevening/theatre-dataverse';
+import StudioStore from './StudioStore/StudioStore';
+import TheatreStudio from './TheatreStudio';
+import { nanoid } from 'nanoid/non-secure';
+import SimpleCache from '@tomorrowevening/theatre-shared/utils/SimpleCache';
+import PaneManager from './PaneManager';
+import { defer } from '@tomorrowevening/theatre-shared/utils/defer';
+import checkForUpdates from './checkForUpdates';
+import shallowEqual from 'shallowequal';
+import { createStore } from './IDBStorage';
+import { getAllPossibleAssetIDs } from '@tomorrowevening/theatre-shared/utils/assets';
+import { notify } from './notify';
+const DEFAULT_PERSISTENCE_KEY = 'theatre-0.4';
+const STUDIO_NOT_INITIALIZED_MESSAGE = `You seem to have imported '@tomorrowevening/theatre-studio' but haven't initialized it. You can initialize the studio by:
+\`\`\`
+import studio from '@tomorrowevening/theatre-studio'
+studio.initialize()
+\`\`\`
+
+* If you didn't mean to import '@tomorrowevening/theatre-studio', this means that your bundler is not tree-shaking it. This is most likely a bundler misconfiguration.
+
+* If you meant to import '@tomorrowevening/theatre-studio' without showing its UI, you can do that by running:
+
+\`\`\`
+import studio from '@tomorrowevening/theatre-studio'
+studio.initialize()
+studio.ui.hide()
+\`\`\`
+`;
+const STUDIO_INITIALIZED_LATE_MSG = `You seem to have imported '@tomorrowevening/theatre-studio' but called \`studio.initialize()\` after some delay.
+Theatre.js projects remain in pending mode (won't play their sequences) until the studio is initialized, so you should place the \`studio.initialize()\` line right after the import line:
+
+\`\`\`
+import studio from '@tomorrowevening/theatre-studio'
+// ... and other imports
+
+studio.initialize()
+\`\`\`
+`;
+export class Studio {
+    ui;
+    // this._uiInitDeferred.promise will resolve once this._ui is set
+    publicApi;
+    address;
+    _projectsProxy = new PointerProxy(new Atom({}).pointer);
+    projectsP = this._projectsProxy.pointer;
+    _store = new StudioStore();
+    _corePrivateApi;
+    _cache = new SimpleCache();
+    paneManager;
+    /**
+     * An atom holding the exports of '\@tomorrowevening/theatre-core'. Will be undefined if '\@tomorrowevening/theatre-core' is never imported
+     */
+    _coreAtom = new Atom({});
+    /**
+     * A Deferred that will resolve once studio is initialized (and its state is read from storage)
+     */
+    _initializedDeferred = defer();
+    /**
+     * Tracks whether studio.initialize() is called.
+     */
+    _initializeFnCalled = false;
+    /**
+     * Will be set to true if studio.initialize() isn't called after 100ms.
+     */
+    _didWarnAboutNotInitializing = false;
+    /**
+     * This will be set as soon as `@tomorrowevening/theatre-core` registers itself on `@tomorrowevening/theatre-studio`
+     */
+    _coreBits;
+    get ticker() {
+        if (!this._rafDriver) {
+            throw new Error('`studio.ticker` was read before studio.initialize() was called.');
+        }
+        return this._rafDriver.ticker;
+    }
+    _rafDriver;
+    get atomP() {
+        return this._store.atomP;
+    }
+    constructor() {
+        this.address = { studioId: nanoid(10) };
+        this.publicApi = new TheatreStudio(this);
+        this.ui = new UI(this);
+        this._attachToIncomingProjects();
+        this.paneManager = new PaneManager(this);
+        // check whether studio.initialize() is called, but only if we're in the browser
+        if (typeof window !== 'undefined') {
+            setTimeout(() => {
+                if (!this._initializeFnCalled) {
+                    console.error(STUDIO_NOT_INITIALIZED_MESSAGE);
+                    this._didWarnAboutNotInitializing = true;
+                }
+            }, 100);
+        }
+    }
+    async initialize(opts) {
+        if (!this._coreBits) {
+            throw new Error(`You seem to have imported \`@tomorrowevening/theatre-studio\` without importing \`@tomorrowevening/theatre-core\`. Make sure to include an import of \`@tomorrowevening/theatre-core\` before calling \`studio.initializer()\`.`);
+        }
+        if (this._initializeFnCalled) {
+            return this._initializedDeferred.promise;
+        }
+        this._initializeFnCalled = true;
+        if (this._didWarnAboutNotInitializing) {
+            console.warn(STUDIO_INITIALIZED_LATE_MSG);
+        }
+        const storeOpts = {
+            persistenceKey: DEFAULT_PERSISTENCE_KEY,
+            usePersistentStorage: true,
+        };
+        if (typeof opts?.persistenceKey === 'string') {
+            storeOpts.persistenceKey = opts.persistenceKey;
+        }
+        if (opts?.usePersistentStorage === false || typeof window === 'undefined') {
+            storeOpts.usePersistentStorage = false;
+        }
+        if (opts?.__experimental_rafDriver) {
+            if (opts.__experimental_rafDriver.type !== 'Theatre_RafDriver_PublicAPI') {
+                throw new Error('parameter `rafDriver` in `studio.initialize({__experimental_rafDriver})` must be either be undefined, or the return type of core.createRafDriver()');
+            }
+            const rafDriverPrivateApi = this._coreBits.privateAPI(opts.__experimental_rafDriver);
+            if (!rafDriverPrivateApi) {
+                // TODO - need to educate the user about this edge case
+                throw new Error('parameter `rafDriver` in `studio.initialize({__experimental_rafDriver})` seems to come from a different version of `@tomorrowevening/theatre-core` than the version that is attached to `@tomorrowevening/theatre-studio`');
+            }
+            this._rafDriver = rafDriverPrivateApi;
+        }
+        else {
+            this._rafDriver = this._coreBits.getCoreRafDriver();
+        }
+        try {
+            await this._store.initialize(storeOpts);
+        }
+        catch (e) {
+            this._initializedDeferred.reject(e);
+            return;
+        }
+        if (process.env.NODE_ENV !== 'test' && typeof window !== 'undefined') {
+            await this.ui.ready;
+        }
+        this._initializedDeferred.resolve();
+        if (process.env.NODE_ENV !== 'test') {
+            this.ui.render();
+            checkForUpdates().catch((err) => {
+                console.error(err);
+            });
+        }
+    }
+    get initialized() {
+        return this._initializedDeferred.promise;
+    }
+    _attachToIncomingProjects() {
+        const projectsD = pointerToPrism(this.projectsP);
+        const attachToProjects = (projects) => {
+            for (const project of Object.values(projects)) {
+                if (!project.isAttachedToStudio) {
+                    project.attachToStudio(this);
+                }
+            }
+        };
+        projectsD.onStale(() => {
+            attachToProjects(projectsD.getValue());
+        });
+        attachToProjects(projectsD.getValue());
+    }
+    setCoreBits(coreBits) {
+        this._coreBits = coreBits;
+        this._corePrivateApi = coreBits.privateAPI;
+        this._coreAtom.setByPointer((p) => p.core, coreBits.coreExports);
+        this._setProjectsP(coreBits.projectsP);
+    }
+    _setProjectsP(projectsP) {
+        this._projectsProxy.setPointer(projectsP);
+    }
+    scrub() {
+        return new Scrub(this);
+    }
+    tempTransaction(fn) {
+        return this._store.tempTransaction(fn);
+    }
+    transaction(fn) {
+        return this.tempTransaction(fn).commit();
+    }
+    __dev_startHistoryFromScratch(newHistoricPart) {
+        return this._store.__dev_startHistoryFromScratch(newHistoricPart);
+    }
+    get corePrivateAPI() {
+        return this._corePrivateApi;
+    }
+    get core() {
+        return this._coreAtom.get().core;
+    }
+    get coreP() {
+        return this._coreAtom.pointer.core;
+    }
+    extend(extension, opts) {
+        if (!extension || typeof extension !== 'object') {
+            throw new Error(`Extensions must be JS objects`);
+        }
+        if (typeof extension.id !== 'string') {
+            throw new Error(`extension.id must be a string`);
+        }
+        const reconfigure = opts?.__experimental_reconfigure === true;
+        const extensionId = extension.id;
+        const prevExtension = this._store.getState().ephemeral.extensions.byId[extensionId];
+        if (prevExtension) {
+            if (reconfigure) {
+            }
+            else {
+                if (extension === prevExtension ||
+                    shallowEqual(extension, prevExtension)) {
+                    // probably running studio.extend() several times because of hot reload.
+                    // as long as it's the same extension, we can safely ignore.
+                    return;
+                }
+                throw new Error(`Extension id "${extension.id}" is already defined. If you mean to re-configure the extension, do it like this: studio.extend(extension, {__experimental_reconfigure: true})})`);
+            }
+        }
+        this.transaction(({ drafts }) => {
+            drafts.ephemeral.extensions.byId[extension.id] = extension;
+            const allPaneClasses = drafts.ephemeral.extensions.paneClasses;
+            if (reconfigure && prevExtension) {
+                // remove all pane classes that were set by the previous version of the extension
+                prevExtension.panes?.forEach((classDefinition) => {
+                    delete allPaneClasses[classDefinition.class];
+                });
+            }
+            // if the extension defines pane classes, add them to the list of all pane classes
+            extension.panes?.forEach((classDefinition) => {
+                if (typeof classDefinition.class !== 'string') {
+                    throw new Error(`pane.class must be a string`);
+                }
+                if (classDefinition.class.length < 3) {
+                    throw new Error(`pane.class should be a string with 3 or more characters`);
+                }
+                const existing = allPaneClasses[classDefinition.class];
+                if (existing) {
+                    if (reconfigure && existing.extensionId === extension.id) {
+                        // well this should never happen because we already deleted the pane class above
+                        console.warn(`Pane class "${classDefinition.class}" already exists. This is a bug in Theatre.js. Please report it at https://github.com/theatre-js/theatre/issues/new`);
+                    }
+                    else {
+                        throw new Error(`Pane class "${classDefinition.class}" already exists and is supplied by extension ${existing}`);
+                    }
+                }
+                allPaneClasses[classDefinition.class] = {
+                    extensionId: extension.id,
+                    classDefinition: classDefinition,
+                };
+            });
+        });
+    }
+    getStudioProject(core) {
+        return this._cache.get('getStudioProject', () => core.getProject('Studio'));
+    }
+    getExtensionSheet(extensionId, core) {
+        return this._cache.get('extensionSheet-' + extensionId, () => this.getStudioProject(core).sheet('Extension ' + extensionId));
+    }
+    undo() {
+        this._store.undo();
+    }
+    redo() {
+        this._store.redo();
+    }
+    createContentOfSaveFile(projectId) {
+        return this._store.createContentOfSaveFile(projectId);
+    }
+    /** A function that returns a promise to an object containing asset storage methods for a project to be used by studio. */
+    async createAssetStorage(project, baseUrl) {
+        // in SSR we bail out and return a dummy asset manager
+        if (typeof window === 'undefined') {
+            return {
+                getAssetUrl: () => '',
+                createAsset: () => Promise.resolve(null),
+            };
+        }
+        // Check for support.
+        if (!('indexedDB' in window)) {
+            if (process.env.NODE_ENV !== 'test')
+                console.log("This browser doesn't support IndexedDB.");
+            return {
+                getAssetUrl: (assetId) => {
+                    throw new Error(`IndexedDB is required by the default asset manager, but it's not supported by this browser. To use assets, please provide your own asset manager to the project config.`);
+                },
+                createAsset: (asset) => {
+                    throw new Error(`IndexedDB is required by the default asset manager, but it's not supported by this browser. To use assets, please provide your own asset manager to the project config.`);
+                },
+            };
+        }
+        const idb = createStore(`${project.address.projectId}-assets`);
+        // get all possible asset ids referenced by either static props or keyframes
+        const possibleAssetIDs = getAllPossibleAssetIDs(project);
+        // Clean up assets not referenced by the project. We can only do this at the start because otherwise
+        // we'd break undo/redo.
+        const idbKeys = await idb.keys();
+        await Promise.all(idbKeys.map(async (key) => {
+            if (!possibleAssetIDs.includes(key)) {
+                await idb.del(key);
+            }
+        }));
+        // Clean up idb entries exported to disk
+        await Promise.all(idbKeys.map(async (key) => {
+            const assetUrl = `${baseUrl}/${key}`;
+            try {
+                const response = await fetch(assetUrl, { method: 'HEAD' });
+                if (response.ok) {
+                    await idb.del(key);
+                }
+            }
+            catch (e) {
+                notify.error('Failed to access assets', `Failed to access assets at ${project.config.assets?.baseUrl ?? '/'}. This is likely due to a CORS issue.`);
+            }
+        }));
+        // A map for caching the assets outside of the db. We also need this to be able to retrieve idb asset urls synchronously.
+        const assetsMap = new Map(await idb.entries());
+        // A map for caching the object urls created from idb assets.
+        const urlCache = new Map();
+        /** Gets idb aset url from asset blob */
+        const getUrlForAsset = (asset) => {
+            if (urlCache.has(asset)) {
+                return urlCache.get(asset);
+            }
+            else {
+                const url = URL.createObjectURL(asset);
+                urlCache.set(asset, url);
+                return url;
+            }
+        };
+        /** Gets idb asset url from id */
+        const getUrlForId = (assetId) => {
+            const asset = assetsMap.get(assetId);
+            if (!asset) {
+                throw new Error(`Asset with id ${assetId} not found`);
+            }
+            return getUrlForAsset(asset);
+        };
+        return {
+            getAssetUrl: (assetId) => {
+                return assetsMap.has(assetId)
+                    ? getUrlForId(assetId)
+                    : `${baseUrl}/${assetId}`;
+            },
+            createAsset: async (asset) => {
+                const existingIDs = getAllPossibleAssetIDs(project);
+                let sameSame = false;
+                if (existingIDs.includes(asset.name)) {
+                    let existingAsset;
+                    try {
+                        existingAsset =
+                            assetsMap.get(asset.name) ??
+                                (await fetch(`${baseUrl}/${asset.name}`).then((r) => r.ok ? r.blob() : undefined));
+                    }
+                    catch (e) {
+                        notify.error('Failed to access assets', `Failed to access assets at ${project.config.assets?.baseUrl ?? '/'}. This is likely due to a CORS issue.`);
+                        return Promise.resolve(null);
+                    }
+                    if (existingAsset) {
+                        const blobCompare = (await import('blob-compare')).default;
+                        // @ts-ignore
+                        sameSame = await blobCompare.isEqual(asset, existingAsset);
+                        // if same same, we do nothing
+                        if (sameSame) {
+                            return asset.name;
+                            // if different, we ask the user to pls rename
+                        }
+                        else {
+                            /** Initiates rename using a dialog. Returns a boolean indicating if the rename was succesful. */
+                            const renameAsset = (text) => {
+                                const newAssetName = prompt(text, asset.name);
+                                if (newAssetName === null) {
+                                    // asset creation canceled
+                                    return false;
+                                }
+                                else if (newAssetName === '') {
+                                    return renameAsset('Asset name cannot be empty. Please choose a different file name for this asset.');
+                                }
+                                else if (existingIDs.includes(newAssetName)) {
+                                    console.log(existingIDs);
+                                    return renameAsset('An asset with this name already exists. Please choose a different file name for this asset.');
+                                }
+                                // rename asset
+                                asset = new File([asset], newAssetName, { type: asset.type });
+                                return true;
+                            };
+                            // rename asset returns false if the user cancels the rename
+                            const success = renameAsset('An asset with this name already exists. Please choose a different file name for this asset.');
+                            if (!success) {
+                                return null;
+                            }
+                        }
+                    }
+                }
+                assetsMap.set(asset.name, asset);
+                await idb.set(asset.name, asset);
+                return asset.name;
+            },
+        };
+    }
+    clearPersistentStorage(persistenceKey = DEFAULT_PERSISTENCE_KEY) {
+        this._store.__experimental_clearPersistentStorage(persistenceKey);
+    }
+}

package/dist/StudioBundle.d.ts

@@ -0,0 +1,10 @@
+import type CoreBundle from '@tomorrowevening/theatre-core/CoreBundle';
+import type { Studio } from './Studio';
+export default class StudioBundle {
+    private readonly _studio;
+    private _coreBundle;
+    constructor(_studio: Studio);
+    get type(): 'Theatre_StudioBundle';
+    registerCoreBundle(coreBundle: CoreBundle): void;
+}
+//# sourceMappingURL=StudioBundle.d.ts.map

package/dist/StudioBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StudioBundle.d.ts","sourceRoot":"","sources":["../../../../studio/src/StudioBundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,0CAA0C,CAAA;AAEtE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAEpC,MAAM,CAAC,OAAO,OAAO,YAAY;IAEnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IADpC,OAAO,CAAC,WAAW,CAAwB;gBACd,OAAO,EAAE,MAAM;IAC5C,IAAI,IAAI,IAAI,sBAAsB,CAEjC;IAED,kBAAkB,CAAC,UAAU,EAAE,UAAU;CAe1C"}

package/dist/StudioBundle.js

@@ -0,0 +1,21 @@
+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.d.ts

@@ -0,0 +1,46 @@
+import type { FullStudioState } from '@tomorrowevening/theatre-studio/store';
+import type { IStateEditors } from '@tomorrowevening/theatre-studio/store/stateEditors';
+import type { StudioAhistoricState, StudioEphemeralState, StudioHistoricState } from '@tomorrowevening/theatre-studio/store/types';
+import type { VoidFn } from '@tomorrowevening/theatre-shared/utils/types';
+import type { Pointer } from '@tomorrowevening/theatre-dataverse';
+import type { Draft } from 'immer';
+import type { OnDiskState } from '@tomorrowevening/theatre-core/projects/store/storeTypes';
+import type { ProjectId } from '@tomorrowevening/theatre-shared/utils/ids';
+export type Drafts = {
+    historic: Draft<StudioHistoricState>;
+    ahistoric: Draft<StudioAhistoricState>;
+    ephemeral: Draft<StudioEphemeralState>;
+};
+export interface ITransactionPrivateApi {
+    set<T>(pointer: Pointer<T>, value: T): void;
+    unset<T>(pointer: Pointer<T>): void;
+    drafts: Drafts;
+    stateEditors: IStateEditors;
+}
+export type CommitOrDiscard = {
+    commit: VoidFn;
+    discard: VoidFn;
+};
+export default class StudioStore {
+    private readonly _reduxStore;
+    private readonly _atom;
+    readonly atomP: Pointer<FullStudioState>;
+    constructor();
+    initialize(opts: {
+        persistenceKey: string;
+        usePersistentStorage: boolean;
+    }): Promise<void>;
+    getState(): FullStudioState;
+    __experimental_clearPersistentStorage(persistenceKey: string): FullStudioState;
+    /**
+     * 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: StudioHistoricState): void;
+    tempTransaction(fn: (api: ITransactionPrivateApi) => void): CommitOrDiscard;
+    undo(): void;
+    redo(): void;
+    createContentOfSaveFile(projectId: ProjectId): OnDiskState;
+}
+//# sourceMappingURL=StudioStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StudioStore.d.ts","sourceRoot":"","sources":["../../../../../studio/src/StudioStore/StudioStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uCAAuC,CAAA;AAM1E,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oDAAoD,CAAA;AAErF,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,6CAA6C,CAAA;AAKpD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,6CAA6C,CAAA;AACvE,OAAO,KAAK,EAAO,OAAO,EAAC,MAAM,oCAAoC,CAAA;AACrE,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,OAAO,CAAA;AAOhC,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yDAAyD,CAAA;AAKxF,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,2CAA2C,CAAA;AAExE,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAA;IACpC,SAAS,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAA;IACtC,SAAS,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAA;CACvC,CAAA;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAA;IAC3C,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,aAAa,CAAA;CAC5B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,CAAC,OAAO,OAAO,WAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwB;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,CAAA;;IAWxC,UAAU,CAAC,IAAI,EAAE;QACf,cAAc,EAAE,MAAM,CAAA;QACtB,oBAAoB,EAAE,OAAO,CAAA;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBjB,QAAQ,IAAI,eAAe;IAI3B,qCAAqC,CACnC,cAAc,EAAE,MAAM,GACrB,eAAe;IAKlB;;;;OAIG;IACH,6BAA6B,CAAC,eAAe,EAAE,mBAAmB;IAQlE,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,eAAe;IAiE3E,IAAI;IAIJ,IAAI;IAIJ,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,WAAW;CA2E3D"}

package/dist/StudioStore/StudioStore.js

@@ -0,0 +1,163 @@
+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.d.ts

@@ -0,0 +1,3 @@
+import type { ITransactionPrivateApi } from './StudioStore';
+export default function createTransactionPrivateApi(ensureRunning: () => void, stateEditors: ITransactionPrivateApi['stateEditors'], drafts: ITransactionPrivateApi['drafts']): ITransactionPrivateApi;
+//# sourceMappingURL=createTransactionPrivateApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTransactionPrivateApi.d.ts","sourceRoot":"","sources":["../../../../../studio/src/StudioStore/createTransactionPrivateApi.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,eAAe,CAAA;AAsEzD,MAAM,CAAC,OAAO,UAAU,2BAA2B,CACjD,aAAa,EAAE,MAAM,IAAI,EACzB,YAAY,EAAE,sBAAsB,CAAC,cAAc,CAAC,EACpD,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACvC,sBAAsB,CAgNxB"}