@tomorrowevening/theatre-studio 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomorrowevening/theatre-studio",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "license": "AGPL-3.0-only",
   "description": "Motion design editor for the web",
   "repository": {

package/dist/IDBStorage.js

@@ -1,19 +0,0 @@
-import * as idb from 'idb-keyval';
-/**
- * Custom IDB keyval storage creator. Right now this exists solely as a more convenient way to use idb-keyval with a custom db name.
- * It also automatically prefixes the provided name with `theatrejs-` to avoid conflicts with other libraries.
- *
- * @param name - The name of the database
- * @returns An object with the same methods as idb-keyval, but with a custom database name
- */
-export const createStore = (name) => {
-    const customStore = idb.createStore(`theatrejs-${name}`, 'default-store');
-    return {
-        set: (key, value) => idb.set(key, value, customStore),
-        get: (key) => idb.get(key, customStore),
-        del: (key) => idb.del(key, customStore),
-        keys: () => idb.keys(customStore),
-        entries: () => idb.entries(customStore),
-        values: () => idb.values(customStore),
-    };
-};

package/dist/PaneManager.js

@@ -1,112 +0,0 @@
-import { prism, val } from '@tomorrowevening/theatre-dataverse';
-import SimpleCache from '@tomorrowevening/theatre-shared/utils/SimpleCache';
-export default class PaneManager {
-    _studio;
-    _cache = new SimpleCache();
-    constructor(_studio) {
-        this._studio = _studio;
-        this._instantiatePanesAsTheyComeIn();
-    }
-    _instantiatePanesAsTheyComeIn() {
-        const allPanesD = this._getAllPanes();
-        allPanesD.onStale(() => {
-            allPanesD.getValue();
-        });
-    }
-    _getAllPanes() {
-        return this._cache.get('_getAllPanels()', () => prism(() => {
-            const core = val(this._studio.coreP);
-            if (!core)
-                return {};
-            const instanceDescriptors = val(this._studio.atomP.historic.panelInstanceDesceriptors);
-            const paneClasses = val(this._studio.atomP.ephemeral.extensions.paneClasses);
-            const instances = {};
-            for (const instanceDescriptor of Object.values(instanceDescriptors)) {
-                if (!instanceDescriptor)
-                    continue;
-                const panelClass = paneClasses[instanceDescriptor.paneClass];
-                if (!panelClass)
-                    continue;
-                const { instanceId } = instanceDescriptor;
-                const { extensionId, classDefinition: definition } = panelClass;
-                const instance = prism.memo(`instance-${instanceDescriptor.instanceId}`, () => {
-                    const inst = {
-                        extensionId,
-                        instanceId,
-                        definition,
-                    };
-                    return inst;
-                }, [definition]);
-                instances[instanceId] = instance;
-            }
-            return instances;
-        }));
-    }
-    get allPanesD() {
-        return this._getAllPanes();
-    }
-    createPane(paneClass) {
-        const core = this._studio.core;
-        if (!core) {
-            throw new Error(`Can't create a pane because @tomorrowevening/theatre-core is not yet loaded`);
-        }
-        const extensionId = val(this._studio.atomP.ephemeral.extensions.paneClasses[paneClass]
-            .extensionId);
-        const allPaneInstances = val(this._studio.atomP.historic.panelInstanceDesceriptors);
-        let instanceId;
-        for (let i = 1; i < 1000; i++) {
-            instanceId = `${paneClass} #${i}`;
-            if (!allPaneInstances[instanceId])
-                break;
-        }
-        if (!extensionId) {
-            throw new Error(`Pane class "${paneClass}" is not registered.`);
-        }
-        this._studio.transaction(({ drafts }) => {
-            drafts.historic.panelInstanceDesceriptors[instanceId] = {
-                instanceId,
-                paneClass,
-            };
-            // Add to focus order (bring new pane to front)
-            if (!drafts.historic.paneFocusOrder) {
-                drafts.historic.paneFocusOrder = [];
-            }
-            const focusOrder = drafts.historic.paneFocusOrder;
-            const existingIndex = focusOrder.indexOf(instanceId);
-            if (existingIndex !== -1) {
-                focusOrder.splice(existingIndex, 1);
-            }
-            focusOrder.push(instanceId);
-        });
-        return this._getAllPanes().getValue()[instanceId];
-    }
-    destroyPane(instanceId) {
-        const core = this._studio.core;
-        if (!core) {
-            throw new Error(`Can't do this yet because @tomorrowevening/theatre-core is not yet loaded`);
-        }
-        this._studio.transaction(({ drafts }) => {
-            delete drafts.historic.panelInstanceDesceriptors[instanceId];
-            // Remove from focus order
-            if (drafts.historic.paneFocusOrder) {
-                const index = drafts.historic.paneFocusOrder.indexOf(instanceId);
-                if (index !== -1) {
-                    drafts.historic.paneFocusOrder.splice(index, 1);
-                }
-            }
-        });
-    }
-    bringPaneToFront(instanceId) {
-        this._studio.transaction(({ drafts }) => {
-            if (!drafts.historic.paneFocusOrder) {
-                drafts.historic.paneFocusOrder = [];
-            }
-            const focusOrder = drafts.historic.paneFocusOrder;
-            const existingIndex = focusOrder.indexOf(instanceId);
-            if (existingIndex !== -1) {
-                focusOrder.splice(existingIndex, 1);
-            }
-            focusOrder.push(instanceId);
-        });
-    }
-}

package/dist/Scrub.js

@@ -1,134 +0,0 @@
-import forEachPropDeep from '@tomorrowevening/theatre-shared/utils/forEachDeep';
-import { getPointerParts } from '@tomorrowevening/theatre-dataverse';
-import { isSheetObject } from '@tomorrowevening/theatre-shared/instanceTypes';
-let lastScrubIdAsNumber = 0;
-export default class Scrub {
-    _studio;
-    _id;
-    _state = { type: 'Ready' };
-    // private readonly _scrubApi: IScrubApi
-    get status() {
-        return this._state.type;
-    }
-    constructor(_studio) {
-        this._studio = _studio;
-        this._id = String(lastScrubIdAsNumber++);
-    }
-    reset() {
-        const { _state: state } = this;
-        if (state.type === 'Ready') {
-            return;
-        }
-        else if (state.type === 'Captured') {
-            this._state = { type: 'Ready' };
-            state.transaction.discard();
-            state.flagsTransaction.discard();
-        }
-        else if (state.type === 'Committed') {
-            throw new Error(`This scrub is already committed and can't be reset.`);
-        }
-        else {
-            throw new Error(`This scrub is already discarded and can't be reset.`);
-        }
-    }
-    commit() {
-        const { _state: state } = this;
-        if (state.type === 'Captured') {
-            state.transaction.commit();
-            state.flagsTransaction.discard();
-            this._state = { type: 'Committed' };
-        }
-        else if (state.type === 'Ready') {
-            console.warn(`Scrub is empty. Nothing to commit.`);
-            return;
-        }
-        else if (state.type === 'Committed') {
-            throw new Error(`This scrub is already committed.`);
-        }
-        else {
-            throw new Error(`This scrub is already discarded and can't be comitted.`);
-        }
-    }
-    capture(fn) {
-        if (this._state.type === 'Captured') {
-            this.reset();
-        }
-        if (this._state.type === 'Ready') {
-            let errored = true;
-            try {
-                this._state = { type: 'Captured', ...this._capture(fn) };
-                errored = false;
-            }
-            finally {
-                if (errored) {
-                    console.error(`This scrub's callback threw an error. We're undo-ing all of the changes made by this scrub, and marking it as discarded.`);
-                    this._state = { type: 'Discarded' };
-                }
-            }
-        }
-        else {
-            if (this._state.type === 'Committed') {
-                throw new Error(`This scrub is already committed and cannot capture again. ` +
-                    `If you wish to capture more, you can start a new studio.scrub() or do so before scrub.commit()`);
-            }
-            else {
-                throw new Error(`This scrub is already discarded and cannot capture again. ` +
-                    `If you wish to capture more, you can start a new studio.scrub() or do so before scrub.discard()`);
-            }
-        }
-    }
-    _capture(fn) {
-        const sets = [];
-        const transaction = this._studio.tempTransaction((transactionApi) => {
-            let running = true;
-            const api = {
-                set: (pointer, value) => {
-                    if (!running) {
-                        throw new Error(`You seem to have called the scrub api after scrub.capture()`);
-                    }
-                    const { root, path } = getPointerParts(pointer);
-                    if (!isSheetObject(root)) {
-                        throw new Error(`We can only scrub props of Sheet Objects for now`);
-                    }
-                    transactionApi.set(pointer, value);
-                    sets.push(pointer);
-                },
-            };
-            try {
-                fn(api);
-            }
-            finally {
-                running = false;
-            }
-        });
-        const flagsTransaction = this._studio.tempTransaction(({ stateEditors }) => {
-            sets.forEach((pointer) => {
-                const { root, path } = getPointerParts(pointer);
-                if (!isSheetObject(root)) {
-                    return;
-                }
-                const defaultValueOfProp = root.template.getDefaultsAtPointer(pointer);
-                forEachPropDeep(defaultValueOfProp, (val, pathToProp) => {
-                    stateEditors.studio.ephemeral.projects.stateByProjectId.stateBySheetId.stateByObjectKey.propsBeingScrubbed.flag({ ...root.address, pathToProp });
-                }, path);
-            });
-        });
-        return { transaction, flagsTransaction };
-    }
-    discard() {
-        const { _state: state } = this;
-        if (state.type === 'Captured' || state.type === 'Ready') {
-            if (state.type === 'Captured') {
-                state.transaction.discard();
-                state.flagsTransaction.discard();
-            }
-            this._state = { type: 'Discarded' };
-        }
-        else if (state.type === 'Committed') {
-            throw new Error(`This scrub is already committed and can't be discarded.`);
-        }
-        else {
-            throw new Error(`This scrub is already discarded`);
-        }
-    }
-}

package/dist/Studio.js

@@ -1,405 +0,0 @@
-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);
-    }
-}