TypeScript promise.cancellableThen函数代码示例

export function volumeCompleter(url: string): CancellablePromise<CompletionResult> {
  // Check if url matches a protocol.  Note that protocolPattern always matches.
  let protocolMatch = url.match(protocolPattern)!;
  let protocol = protocolMatch[1];
  if (protocol === undefined) {
    // Return protocol completions.
    let completions: Completion[] = [];
    for (let [name, factory] of dataSourceFactories) {
      name = name + '://';
      if (name.startsWith(url)) {
        completions.push({value: name, description: factory.description});
      }
    }
    return Promise.resolve({offset: 0, completions});
  }
  let factory = dataSourceFactories.get(protocol);
  if (factory !== undefined) {
    let subCompleter = factory.volumeCompleter;
    if (subCompleter !== undefined) {
      return cancellableThen(
          subCompleter(protocolMatch[2]),
          completions => applyCompletionOffset(protocol.length + 3, completions));
    }
  }
  return Promise.reject<CompletionResult>(null);
}

export function tokenAndChannelCompleter(hostnames: string[], path: string): CancellablePromise<CompletionResult> {
  let channelMatch = path.match(/^(?:([^\/]+)(?:\/([^\/]*))?)?$/);
  if (channelMatch === null) {
    // URL has incorrect format, don't return any results.
    return Promise.reject<CompletionResult>(null);
  }
  if (channelMatch[2] === undefined) {
    let keyPrefix = channelMatch[1] || '';
    // Try to complete the token.
    return getPublicTokens(hostnames).then(tokens => {
      return {
        offset: 0,
        completions:
            getPrefixMatchesWithDescriptions(keyPrefix, tokens, x => x + '/', x => undefined)
      };
    });
  }
  return cancellableThen(getVolumeInfo(hostnames, channelMatch[1]), response => {
    let completions: Completion[] = [];
    if (typeof response === 'object' && response !== null && !Array.isArray(response)) {
      let channelsObject = response['channels'];
      if (typeof channelsObject === 'object' && channelsObject !== null &&
          !Array.isArray(channelsObject)) {
        let channelNames = Object.keys(channelsObject);
        completions =
            getPrefixMatchesWithDescriptions(channelMatch[2], channelNames, x => x, x => {
              let channelObject = channelsObject[x];
              return `${channelObject['channel_type']} (${channelObject['datatype']})`;

            });
      }
    }
    return {offset: channelMatch[1].length + 1, completions};
  });
}

export function tokenAndChannelCompleter(
    hostnames: string[], path: string): CancellablePromise<CompletionResult> {
  let channelMatch = path.match(/^(?:([^\/]+)(?:\/([^\/]*))?)?$/);
  if (channelMatch === null) {
    // URL has incorrect format, don't return any results.
    return Promise.reject<CompletionResult>(null);
  }
  if (channelMatch[2] === undefined) {
    let keyPrefix = channelMatch[1] || '';
    // Try to complete the token.
    return getPublicTokens(hostnames).then(tokens => {
      return {
        offset: 0,
        completions:
            getPrefixMatchesWithDescriptions(keyPrefix, tokens, x => x + '/', x => undefined)
      };
    });
  }
  return cancellableThen(getTokenInfo(hostnames, channelMatch[1]), tokenInfo => {
    let completions = getPrefixMatchesWithDescriptions(
        channelMatch![2], tokenInfo.channels, x => x[0],
        x => { return `${x[1].channelType} (${DataType[x[1].dataType]})`; });
    return {offset: channelMatch![1].length + 1, completions};
  });
}

export function volumeCompleter(url: string): CancellablePromise<CompletionResult> {
  let match = url.match(urlPattern);
  if (match === null) {
    // We don't yet have a full hostname.
    return Promise.reject<CompletionResult>(null);
  }
  let hostnames = [match[1]];
  let path = match[2];
  return cancellableThen(
      tokenAndChannelCompleter(hostnames, path),
      completions => applyCompletionOffset(match[1].length + 1, completions));
}