TypeScript WindowResolver.resolve方法代码示例

  activate: async (app: JupyterLab, router: IRouter) => {
    const resolver = new WindowResolver();
    const match = router.current.path.match(Patterns.workspace);
    const workspace = (match && decodeURIComponent(match[1])) || '';
    const candidate = workspace
      ? URLExt.join(
          PageConfig.getOption('baseUrl'),
          PageConfig.getOption('workspacesUrl'),
          workspace
        )
      : app.info.defaultWorkspace;

    try {
      await resolver.resolve(candidate);
    } catch (error) {
      console.warn('Window resolution failed:', error);

      // Return a promise that never resolves.
      return new Promise<IWindowResolver>(() => {
        Private.redirect(router);
      });
    }

    PageConfig.setOption('workspace', resolver.name);

    return resolver;
  }

  activate: async (
    _: JupyterFrontEnd,
    paths: JupyterFrontEnd.IPaths,
    router: IRouter
  ) => {
    const { hash, path, search } = router.current;
    const query = URLExt.queryStringToObject(search || '');
    const solver = new WindowResolver();
    const match = path.match(new RegExp(`^${paths.urls.workspaces}([^?\/]+)`));
    const workspace = (match && decodeURIComponent(match[1])) || '';
    const candidate = Private.candidate(paths, workspace);

    try {
      await solver.resolve(candidate);
    } catch (error) {
      // Window resolution has failed so the URL must change. Return a promise
      // that never resolves to prevent the application from loading plugins
      // that rely on `IWindowResolver`.
      return new Promise<IWindowResolver>(() => {
        // If the user has requested workspace resolution create a new one.
        if (WORKSPACE_RESOLVE in query) {
          const { base, workspaces } = paths.urls;
          const pool =
            'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
          const random = pool[Math.floor(Math.random() * pool.length)];
          const path = URLExt.join(base, workspaces, `auto-${random}`);

          // Clone the originally requested workspace after redirecting.
          query['clone'] = workspace;

          // Change the URL and trigger a hard reload to re-route.
          const url = path + URLExt.objectToQueryString(query) + (hash || '');
          router.navigate(url, { hard: true, silent: true });
          return;
        }

        // Launch a dialog to ask the user for a new workspace name.
        console.warn('Window resolution failed:', error);
        return Private.redirect(router, paths, workspace);
      });
    }

    // If the user has requested workspace resolution remove the query param.
    if (WORKSPACE_RESOLVE in query) {
      delete query[WORKSPACE_RESOLVE];

      // Silently scrub the URL.
      const url = path + URLExt.objectToQueryString(query) + (hash || '');
      router.navigate(url, { silent: true });
    }

    return solver;
  }

  activate: (app: JupyterLab, router: IRouter) => {
    const candidate = Private.getWorkspace(router) || '';
    const resolver = new WindowResolver();

    return resolver.resolve(candidate)
      .catch(reason => {
        console.warn('Window resolution failed:', reason);

        return Private.redirect(router);
      })
      .then(() => {
        PageConfig.setOption('workspace', resolver.name);

        return resolver;
      });
  }

  activate: async (
    _: JupyterFrontEnd,
    paths: JupyterFrontEnd.IPaths,
    router: IRouter
  ) => {
    const { hash, path, search } = router.current;
    const query = URLExt.queryStringToObject(search || '');
    const solver = new WindowResolver();
    const match = path.match(new RegExp(`^${paths.urls.workspaces}([^?\/]+)`));
    const workspace = (match && decodeURIComponent(match[1])) || '';
    const candidate = Private.candidate(paths, workspace);
    const rest = workspace
      ? path.replace(new RegExp(`^${paths.urls.workspaces}${workspace}`), '')
      : path.replace(new RegExp(`^${paths.urls.page}`), '');

    try {
      await solver.resolve(candidate);
      return solver;
    } catch (error) {
      // Window resolution has failed so the URL must change. Return a promise
      // that never resolves to prevent the application from loading plugins
      // that rely on `IWindowResolver`.
      return new Promise<IWindowResolver>(() => {
        const { base, workspaces } = paths.urls;
        const pool =
          'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
        const random = pool[Math.floor(Math.random() * pool.length)];
        const path = URLExt.join(base, workspaces, `auto-${random}`) + rest;

        // Clone the originally requested workspace after redirecting.
        query['clone'] = workspace;

        // Change the URL and trigger a hard reload to re-route.
        const url = path + URLExt.objectToQueryString(query) + (hash || '');
        router.navigate(url, { hard: true, silent: true });
      });
    }
  }