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
git@github.com:${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
*/
