TypeScript Observable.bindNodeCallback方法代碼示例

 */
import * as _ from 'lodash';
import { Observable, Subscription } from 'rxjs';
import { CommandType, Definition, IAtomNavigation, IDefinitionProvider, IDefinitionService, Reference, navigationHasRange } from 'atom-languageservices';
import { alias, injectable } from 'atom-languageservices/decorators';
import { readFile } from 'fs';
import { ProviderServiceBase } from './_ProviderServiceBase';
import { atomConfig } from '../decorators';
import { AtomCommands } from './AtomCommands';
import { AtomNavigation } from './AtomNavigation';
import { AtomTextEditorSource } from './AtomTextEditorSource';
import { CommandsService } from './CommandsService';
import { ReferenceView } from './views/ReferenceView';
type Location = IAtomNavigation.Location;

const readFile$ = Observable.bindNodeCallback(readFile);
@injectable
@alias(IDefinitionService)
@atomConfig({
    default: true,
    description: 'Adds support for navigate to definition or definitions'
})
export class DefinitionService
    extends ProviderServiceBase<IDefinitionProvider, Definition.IRequest, Observable<Location[]>, Observable<Location[]>>
    implements IDefinitionService {
    private _navigation: AtomNavigation;
    private _commands: CommandsService;
    private _atomCommands: AtomCommands;
    private _source: AtomTextEditorSource;

    constructor(navigation: AtomNavigation, commands: CommandsService, atomCommands: AtomCommands, source: AtomTextEditorSource) {

import { exec } from 'child_process';
import * as fs from 'fs';
import { join } from 'path';
import { Observable } from 'rxjs';
import { ILogger, IOmnisharpPlugin } from '../enums';
import { createObservable } from '../operators/create';
import { RuntimeContext } from './runtime';

const bootstrappedPlugins = new Map<string, string>();
const exists = Observable.bindCallback(fs.exists);
const readFile: (file: string) => Observable<any> = Observable.bindNodeCallback(fs.readFile);
// tslint:disable-next-line:no-var-requires no-require-imports
const md5: (value: any) => string = require('md5');

// tslint:disable-next-line:export-name
export function getPluginPath(solutionLocation: string, ctx: RuntimeContext, requestedPlugins: IOmnisharpPlugin[], logger: ILogger) {
    const plugins: any[] = [];
    const hashStrings: any[] = [];
    let hash: string;
    requestedPlugins.forEach(plugin => {
        plugins.push(plugin);
    });

    return createObservable<string>(observer => {
        logger.log('Bootstrapping ' + solutionLocation);
        // Include the plugins defined in omnisharp.json, they could have changed.
        exists(join(solutionLocation, 'omnisharp.json'))
            .filter(x => !!x)
            .flatMap(x => readFile(join(solutionLocation, 'omnisharp.json')))
            .map(x => JSON.parse(x.toString()))
            .do({

 return (collection: Collection): Observable<void> => {
   let cb: Function = collection.createIndex.bind(collection);
   let opts: Object = { unique: true };
   return Observable.bindNodeCallback<void>(cb)(field, opts);
 }

    Observable.create(function (observer) {
        function writeFileStreamCB(e, file) {
            if (e) return observer.error(e);

            observer.next(merge(
                getFilenameMetaData(path || ''),
                {file}
            ));
            observer.complete();
        }

        fs.writeFile(path, data, writeFileStreamCB);
    });


const xmlToObservable = Observable.bindNodeCallback(parseString);

function isFeedItem(x:OutlineFeedParent|OutlineFolderParent):x is OutlineFeedParent {
    return compose(
        lt(0),
        length,
        path(['$', 'xmlUrl'])
    )(x)
}

const getOutline:(x:OutlineFolderParent) => Array<OutlineFolderParent> = prop('outline');


const sortableURI:(x:string) => string = (x = '')=> {
    const u = new URI(x);
    return u.hostname()

 connect(uri: string): Observable<MongoDb> {
   let client = new MongoClient();
   let cb: Function = client.connect.bind(client);
   return Observable.bindNodeCallback<MongoDb>(cb)(uri);
 }

import {Observable} from 'rxjs';
import {writeFile as writeFile_} from 'fs';

export const writeFile = Observable.bindNodeCallback(writeFile_);