TypeScript StateDB.toJSON方法代碼示例

 debouncer = window.setTimeout(() => {
   state.toJSON()
     .then(data => workspaces.save(id, { data, metadata }))
     .then(() => {
       conflated.resolve(undefined);
       conflated = null;
     })
     .catch(reason => {
       conflated.reject(reason);
       conflated = null;
     });
 }, timeout);

        debouncer = window.setTimeout(async () => {
          const data = await db.toJSON();

          try {
            await workspaces.save(id, { data, metadata });
            if (conflated) {
              conflated.resolve(undefined);
            }
          } catch (error) {
            if (conflated) {
              conflated.reject(error);
            }
          }
          conflated = null;
        }, timeout);

        debouncer = window.setTimeout(async () => {
          // Prevent a race condition between the timeout and saving.
          if (!conflated) {
            return;
          }

          const data = await state.toJSON();

          try {
            await workspaces.save(id, { data, metadata });
            conflated.resolve(undefined);
          } catch (error) {
            conflated.reject(error);
          }
          conflated = null;
        }, timeout);

        debouncer = window.setTimeout(() => {
          // Prevent a race condition between the timeout and saving.
          if (!conflated) {
            return;
          }

          state.toJSON()
            .then(data => workspaces.save(id, { data, metadata }))
            .then(() => {
              conflated.resolve(undefined);
              conflated = null;
            })
            .catch(reason => {
              conflated.reject(reason);
              conflated = null;
            });
        }, timeout);

    it('return the full contents of a state database', async () => {
      const { localStorage } = window;

      const db = new StateDB({ namespace: 'test-namespace' });
      const contents: ReadonlyJSONObject = {
        abc: 'def',
        ghi: 'jkl',
        mno: 1,
        pqr: {
          foo: { bar: { baz: 'qux' } }
        }
      };

      expect(localStorage.length).to.equal(0);
      await Promise.all(
        Object.keys(contents).map(key => db.save(key, contents[key]))
      );
      const serialized = await db.toJSON();
      expect(serialized).to.deep.equal(contents);
      await db.clear();
    });

      execute: (args: IRouter.ILocation) => {
        // Since the command can be executed an arbitrary number of times, make
        // sure it is safe to call multiple times.
        if (resolved) {
          return;
        }

        const { hash, path, search } = args;
        const workspace = Private.getWorkspace(router);
        const query = URLExt.queryStringToObject(search || '');
        const clone = query['clone'];
        const source = typeof clone === 'string' ? clone : workspace;

        let promise: Promise<any>;

        // If the default /lab workspace is being cloned, copy it out of local
        // storage instead of making a round trip to the server because it
        // does not exist on the server.
        if (source === clone && source === '') {
          const prefix = `${source}:${info.namespace}:`;
          const mask = (key: string) => key.replace(prefix, '');
          const contents = StateDB.toJSON(prefix, mask);

          resolved = true;
          transform.resolve({ type: 'overwrite', contents });
          promise = Promise.resolve();
        }

        // If there is no promise, fetch the source and overwrite the database.
        promise =
          promise ||
          workspaces
            .fetch(source)
            .then(saved => {
              // If this command is called after a reset, the state database
              // will already be resolved.
              if (!resolved) {
                resolved = true;
                transform.resolve({ type: 'overwrite', contents: saved.data });
              }
            })
            .catch(reason => {
              console.warn(`Fetching workspace (${workspace}) failed:`, reason);

              // If the workspace does not exist, cancel the data transformation
              // and save a workspace with the current user state data.
              if (!resolved) {
                resolved = true;
                transform.resolve({ type: 'cancel', contents: null });
              }
            })
            .then(() => {
              // Any time the local state database changes, save the workspace.
              if (workspace) {
                state.changed.connect(listener, state);
              }
            });

        return promise
          .catch(reason => {
            console.warn(`${CommandIDs.loadState} failed:`, reason);
          })
          .then(() => {
            const immediate = true;

            if (source === clone) {
              // Maintain the query string parameters but remove `clone`.
              delete query['clone'];

              const url = path + URLExt.objectToQueryString(query) + hash;
              const cloned = commands
                .execute(CommandIDs.saveState, { immediate })
                .then(() => router.stop);

              // After the state has been cloned, navigate to the URL.
              cloned.then(() => {
                router.navigate(url, { silent: true });
              });

              return cloned;
            }

            // After the state database has finished loading, save it.
            return commands.execute(CommandIDs.saveState, { immediate });
          });
      }

 .then(() => db.toJSON())