TypeScript history.History类代码示例

  push(path: string | LocationDescriptorObject, state?: any) {
    // Do not navigate if the path object matches
    const nextPath = typeof path === 'string' ? path : createPath(path);
    if (nextPath === createPath(this.history.location)) return;

    if (Date.now() - this.lastPush > this.wait) {
      // @ts-ignore TypeScript doesn't recognize our push as a proxy for History.push's
      // overloaded signature, and it's really hard to fix this properly
      this.history.push(path, state);
    } else {
      try {
        // @ts-ignore
        this.history.replace(path, state);
      } catch (e) {
        // Ignore Safari's history.replaceState() rate limit error.
        // See https://github.com/nusmodifications/nusmods/issues/763
        if (
          e.name === 'SecurityError' &&
          e.message.includes('Attempt to use history.replaceState()')
        ) {
          return;
        }

        // Continue throwing all other errors
        throw e;
      }
    }

    this.lastPush = Date.now();
  }

export function createHistory$(history: History,
                               sink$: Stream<HistoryInput | string>): MemoryStream<Location> {
  const history$ = xs.createWithMemory<Location>().startWith(history.location);
  const call = makeCallOnHistory(history);
  const unlisten = history.listen((loc: Location) => { history$._n(loc); });
  const sub = sink$.subscribe(createObserver(call, unlisten));
  (history$ as any).dispose = () => { sub.unsubscribe(); unlisten(); };
  return history$;
};

export function trackPageView(history: History) {
  history.listen((location, action) => {
    if (action === 'PUSH') {
      // Wait a bit for the page title to update
      setTimeout(() => {
        withTracker((tracker) => tracker.trackPageView(document.title));
      }, 100);
    }
  });
}

  return function call(input: Narrow<HistoryInput>): void {
    if (input.type === 'push') {
      history.push(input.pathname, input.state);
    }

    if (input.type === 'replace') {
      history.replace(input.pathname, input.state);
    }

    if (input.type === 'go') {
      history.go(input.amount);
    }

    if (input.type === 'goBack') {
      history.goBack();
    }

    if (input.type === 'goForward') {
      history.goForward();
    }
  };

export const updateSearch = (
  history: History,
  updates: { readonly [id: string]: any },
) => {
  history.push({
    pathname: history.location.pathname,
    search: qs.stringify({
      ...qs.parse(history.location.search),
      ...updates,
    }),
  });
};

   export function updateEditor(fileResource: FileResource) { // why would you ever ignore an update here?
      var resourcePath: FilePath = fileResource.getResourcePath();
      var isReadOnly = fileResource.isHistorical() || fileResource.isError();
      var realText: string = fileResource.getFileContent();
      var textToDisplay = resolveEditorTextToUse(fileResource);
      var session = editorView.getEditorPanel().getSession();
      var currentMode = session.getMode();
      var actualMode = resolveEditorMode(resourcePath.getResourcePath());

      saveEditorHistory(); // save any existing history
      
      if(actualMode != currentMode) {
         session.setMode({
            path: actualMode,
            v: Date.now() 
         })
      }
      if(!isReadOnly) {
         createEditorUndoManager(session, textToDisplay, realText, resourcePath); // restore any existing history      
      } else {
         createEditorWithoutUndoManager(textToDisplay);
      }
      clearEditor();
      setReadOnly(isReadOnly);
      
      editorView.updateResourcePath(resourcePath, isReadOnly);
      ProblemManager.highlightProblems(); // higlight problems on this resource
      
      if (resourcePath != null && editorView.getEditorResource()) {
         var filePath: string = editorView.getEditorResource().getFilePath();
         var allBreakpoints = editorView.getEditorBreakpoints();
         var breakpoints = allBreakpoints[filePath];
   
         if (breakpoints != null) {
            for(var lineNumber in breakpoints) {
               if (breakpoints.hasOwnProperty(lineNumber)) {
                  if (breakpoints[lineNumber] == true) {
                     setEditorBreakpoint(parseInt(lineNumber) - 1, true);
                  }
               }
            }
         }
      }
      Project.createEditorTab(); // update the tab name
      History.showFileHistory(); // update the history
      StatusPanel.showActiveFile(editorView.getEditorResource().getProjectPath());  
      FileEditor.showEditorFileInTree();
      scrollEditorToPosition();
      updateEditorTabMark(); // add a * to the name if its not in sync
   }

export function* authSaga(
    history: History,
    authApi: IAuthApi,
    usersApi: IUsersApi
) {
    let token: IToken = yield call(authApi.getAuthToken)

    if (token) {
        token = yield call(login, history, authApi, usersApi, { type: 'token', token })
    } else {
        yield put(actions.logoutSuccess())
    }

    yield put(actions.authCheckFinished(token && token.value || null))

    while (true) {
        if (!token) {
            const { payload: credentials } = yield take(actions.login.getType())
            token = yield call(login, history, authApi, usersApi, credentials)
            if (token) {
                history.push('/')
            }
        }

        if (!token) {
            continue
        }

        let userLoggedOut = false
        while (!userLoggedOut) {
            const { expired } = yield race({
                expired: delay(Math.max(token.exp - Date.now() - 30000, 0)),
                loggedOut: take(actions.logout.getType()),
            })

            if (expired) {
                token = yield call(login, history, authApi, usersApi, { type: 'token', token })
            } else {
                yield call(logout, authApi)
                userLoggedOut = true
            }
        }
    }
}

 function onBrowserChange(callback: (s: BrowserState, action: Action) => void): void {
   history.listen((location, action) => {
     currentPath = locationToPathConfigAndMatch(paths, location).path;
     callback(parseBrowserState(paths, location), action);
   });
   callback(parseBrowserState(paths, history.location), 'PUSH');
 }

 return (key: string, value?) => {
   if (value === "") {
     delete querystring[key];
   } else {
     querystring[key] = value || key;
   }
   history.replace("?" + stringifyQs(querystring));
 };

  run (sink: Sink<Location>, scheduler: Scheduler) {
    const push = (l: Location) => sink.event(scheduler.now(), l);

    const unlisten = this.history.listen(push);

    return {
      dispose () {
        unlisten();
        sink.end(scheduler.now());
      }
    };
  }