export function createTsSourceFile(fileName: string): Promise<ts.SourceFile> {
  const readFile = denodeify(fs.readFile);
  return readFile(fileName, 'utf8')
    .then((contents: string) => {
      return ts.createSourceFile(fileName, contents, ts.ScriptTarget.ES6, true);
    });
}

 .then(doc => {
     switch (doc.type) {
         case 'apib':
             return denodeify(apib2swagger.convert)(doc.body).then(r => r['swagger'])
         default:
             return JSON.parse(doc.body)
     }
 })

  run: function(commandOptions: any) {
    const ui = this.ui;
    let promise: Promise<any>;

    // declared here so that tests can stub exec
    const execPromise = denodeify(exec);

    if (/.+/.test(commandOptions.ghToken) && /\w+/.test(commandOptions.ghUsername)) {
      promise = Promise.resolve({
        ghToken: commandOptions.ghToken,
        ghUsername: commandOptions.ghUsername
      });
    } else {
      ui.writeLine();
      ui.writeLine(oneLine`
        In order to deploy this project via GitHub Pages, we must first create a repository for it.
      `);
      ui.writeLine(oneLine`
        It\'s safer to use a token than to use a password so you will need to create one
      `);
      ui.writeLine('Go to the following page and click "Generate new token".');
      ui.writeLine('https://github.com/settings/tokens\n');
      ui.writeLine('Choose "public_repo" as scope and then click "Generate token".\n');
      promise = ui.prompt([
        {
          name: 'ghToken',
          type: 'input',
          message: oneLine`
            Please enter GitHub token you just created
            (used only once to create the repo):
          `,
          validate: function(token: string) {
            return /.+/.test(token);
          }
        }, {
          name: 'ghUsername',
          type: 'input',
          message: 'and your GitHub user name:',
          validate: function(userName: string) {
            return /\w+/.test(userName);
          }
        }]);
    }

    return promise
      .then((answers) => {
      return new Promise(function(resolve, reject) {
        const postData = JSON.stringify({
          'name': commandOptions.projectName
        });

        const req = https.request({
          hostname: 'api.github.com',
          port: 443,
          path: '/user/repos',
          method: 'POST',
          headers: {
            'Authorization': `token ${answers.ghToken}`,
            'Content-Type': 'application/json',
            'Content-Length': postData.length,
            'User-Agent': 'angular-cli-github-pages'
          }
        });

        req.on('response', function(response: any) {
          if (response.statusCode === 201) {
            resolve(execPromise(oneLine`
              git remote add origin 
              [email protected]:${answers.ghUsername}/${commandOptions.projectName}.git
            `));
          } else {
            reject(new SilentError(oneLine`
              Failed to create GitHub repo. Error: ${response.statusCode} ${response.statusMessage}
            `));
          }
        });

        req.write(postData);
        req.end();
      });
    });
  }

import {Option} from '../../server/src/Option';
import * as denodeify from 'denodeify';
import {exec as execNode, ExecOptions} from 'child_process';

type Stdout = string;
type Stderr = string;
type ExecResult = [ Stdout, Stderr ];
export const exec: (command: string, options: ExecOptions) => Promise<ExecResult> = (
    denodeify(execNode, (err, stdout, stderr) => [err, [stdout, stderr]])
);
export type StringDictionary<T> = { [key: string]: T };
export const getInStringDictionary = <T>(stringDictionary: StringDictionary<T>, key: number): T | undefined => stringDictionary[key]
export const getInArray = <T>(array: T[], index: number): T | undefined => array[index]
export const OptionHelpers = {
    fromNullable<T>(t: T | null | undefined): Option<T> { return Option(t as T) },
    arrayGet<T>(array: T[], index: number): Option<T> {
        return OptionHelpers.fromNullable(getInArray(array, index))
    },
    stringMatch(str: string, matcher: RegExp): Option<RegExpMatchArray> {
        return OptionHelpers.fromNullable(str.match(matcher))
    },
}
export const stringify = (json: any) => JSON.stringify(json, null, '    ');
export const writePromise = (promise: Promise<string>): Promise<void> => (
    promise.then(
        output => { process.stdout.write(output) },
        error => {
            process.stderr.write(error.stack)
            process.exit(1)
        },
    )

"use strict";

import * as fs from 'fs-extra';
import * as denodeify from 'denodeify';

import {CompilableContent, ICompilableContent} from './CompilableContent';
import {error} from './Logger';

var fsreadfile = denodeify(fs.readFile);

/**
 * Doc wraps up all occurances of markdown documents inside the styleguide.
 */
export class Doc extends CompilableContent {
  load():Promise<ICompilableContent> {
    return super.load()
    .then((doc) => {
      this.compiled = this.render();
      return this;
    })
    .catch(e => {
      error("Doc.load", e);
      console.log(e.stack);
      throw(e);
    });
  }

  static create(path: string, name: string): ICompilableContent {
    var doc:Doc = new Doc(path, name);
    doc.renderer = this.renderer;
    return doc;

import {StructureReader} from './StructureReader';
import {StructureWriter} from './StructureWriter';
import {Node} from './Node';
import {ComponentList} from './ComponentList';
import {IRenderer, IRendererOptions} from './Renderer';
import {IPageConfig} from './Page';
import {LinkRegistry} from './LinkRegistry';

import {Doc} from './Doc';
import {Partial} from './Partial';
import {View} from './View';

import {MarkdownRenderer} from './MarkdownRenderer';
import {HandlebarsRenderer} from './HandlebarsRenderer';

var fsensuredir = denodeify(fs.ensureDir);
var fscopy = denodeify(fs.copy);
var outputfile = denodeify(fs.outputFile);

var flatten = (list) => list.reduce(
  (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);

interface IStyleguideOptions {
  configPath?: string;
  target?: string;
  cwd?: string;
}

interface IAssetCopyConfig {
  src?: string;

import * as fs from 'fs-extra';
import * as path from 'path';
import * as slug from 'slug';
import * as denodeify from 'denodeify';

import {Doc} from './Doc';
import {View} from './View';
import {Styleguide} from './Styleguide';
import {IRenderer} from './Renderer';
import {IPageLayoutContext} from './PageLayout';
import {PlainComponentList, IRelatedComponentFiles} from './PlainComponentList';
import {ICompilableContent} from './CompilableContent';
import {warn, error} from './Logger';

var fsoutputfile = denodeify(fs.outputFile);

export interface IPageConfig {
  id?: string;
  label?: string;
  slug?: string;
  type?: string;
  content?: any;
  children?: Page[];
  styleguide?: Styleguide;
  mdRenderer?: IRenderer;
  target?: string;
  preflight?: string;
}

export interface IPageTemplateConfig {

import { assign } from 'lodash';
import * as _read from 'read';
import * as fs from 'fs';
import * as path from 'path';
import { WebApi, getBasicHandler } from 'vso-node-api/WebApi';
import { IGalleryApi, IQGalleryApi } from 'vso-node-api/GalleryApi';
import * as denodeify from 'denodeify';

const readFile = denodeify<string, string, string>(fs.readFile);

export function fatal<T>(message: any, ...args: any[]): Promise<T> {
	if (message instanceof Error) {
		if (/^cancell?ed$/i.test(message.message)) {
			return;
		}

		message = message.message;
	}

	console.error('Error:', message, ...args);
	process.exit(1);
	return Promise.resolve<T>(null);
}

export function catchFatal<T>(promise: Promise<T>): Promise<T> {
	return promise.catch<T>(fatal);
}

const __read = denodeify<_read.Options,string>(_read);
export function read(prompt: string, options: _read.Options = {}): Promise<string> {
	return __read(assign({ prompt }, options));

import * as denodeify from 'denodeify';

const SilentError = require('silent-error');
const PortFinder = require('portfinder');
const getPort = denodeify<{host: string, port: number}, number>(PortFinder.getPort);

export function checkPort(port: number, host: string, basePort = 49152): Promise<number> {
  PortFinder.basePort = basePort;
  return getPort({ port, host })
    .then(foundPort => {

      // If the port isn't available and we weren't looking for any port, throw error.
      if (port !== foundPort && port !== 0) {
        throw new SilentError(
          `Port ${port} is already in use. Use '--port' to specify a different port.`
        );
      }

      // Otherwise, our found port is good.
      return foundPort;
    });
}

"use strict";

import * as path from 'path';
import * as fs from 'fs-extra';
import * as denodeify from 'denodeify';

import {warn} from './Logger';
import {Config} from './Config';
import {Styleguide} from './Styleguide';
import {IComponentConfig} from './Component';
import {Component} from './Component';
import {Partial} from './Partial';

var fsstat = denodeify(fs.stat);
var fsreaddir = denodeify(fs.readdir);


/** options, that can be handed to nodes */
export interface INodeOptions {
  namespace?: string;
  styleguide?: Styleguide;
  componentDocs?: string;
}

/**
 * a Node represents a folder-node inside of the configured component paths.
 * It may have a Component (1-to-1), but maybe it is just a container for
 * child nodes, that are components.
 *
 * TODO: i guess nodes may also be pages
 */