@angular-devkit/core 0.0.10 → 0.0.15

package/src/virtual-fs/path.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { BaseException } from '@angular-devkit/core';
+export declare class InvalidPathException extends BaseException {
+    constructor(path: string);
+}
+export declare class PathMustBeAbsoluteException extends BaseException {
+    constructor(path: string);
+}
+/**
+ * A Path recognized by most methods in the DevKit.
+ */
+export declare type Path = string & {
+    __PRIVATE_DEVKIT_PATH: void;
+};
+/**
+ * The Separator for normalized path.
+ * @type {Path}
+ */
+export declare const NormalizedSep: Path;
+/**
+ * The root of a normalized path.
+ * @type {Path}
+ */
+export declare const NormalizedRoot: Path;
+/**
+ * Split a path into multiple path fragments. Each fragments except the last one will end with
+ * a path separator.
+ * @param {Path} path The path to split.
+ * @returns {Path[]} An array of path fragments.
+ */
+export declare function split(path: Path): Path[];
+/**
+ *
+ */
+export declare function extname(path: Path): string;
+/**
+ * This is the equivalent of calling dirname() over and over, until the root, then getting the
+ * basename.
+ *
+ * @example rootname('/a/b/c') == 'a'
+ * @example rootname('a/b') == '.'
+ * @param path The path to get the rootname from.
+ * @returns {Path} The first directory name.
+ */
+export declare function rootname(path: Path): Path;
+/**
+ * Return the basename of the path, as a Path. See path.basename
+ */
+export declare function basename(path: Path): Path;
+/**
+ * Return the dirname of the path, as a Path. See path.dirname
+ */
+export declare function dirname(path: Path): Path;
+/**
+ * Join multiple paths together, and normalize the result. Accepts strings that will be
+ * normalized as well (but the original must be a path).
+ */
+export declare function join(p1: Path, ...others: string[]): Path;
+/**
+ * Returns true if a path is absolute.
+ */
+export declare function isAbsolute(p: Path): boolean;
+/**
+ * Returns a path such that `join(from, relative(from, to)) == to`.
+ * Both paths must be absolute, otherwise it does not make much sense.
+ */
+export declare function relative(from: Path, to: Path): Path;
+/**
+ * Returns a Path that is the resolution of p2, from p1. If p2 is absolute, it will return p2,
+ * otherwise will join both p1 and p2.
+ */
+export declare function resolve(p1: Path, p2: Path): Path;
+/**
+ * Normalize a string into a Path. This is the only mean to get a Path type from a string that
+ * represents a system path. Normalization includes:
+ *   - Windows backslashes `\\` are replaced with `/`.
+ *   - Windows drivers are replaced with `/X/`, where X is the drive letter.
+ *   - Absolute paths starts with `/`.
+ *   - Multiple `/` are replaced by a single one.
+ *   - Path segments `.` are removed.
+ *   - Path segments `..` are resolved.
+ *   - If a path is absolute, having a `..` at the start is invalid (and will throw).
+ */
+export declare function normalize(path: string): Path;

package/src/virtual-fs/path.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const core_1 = require("@angular-devkit/core");
+class InvalidPathException extends core_1.BaseException {
+    constructor(path) { super(`Path ${JSON.stringify(path)} is invalid.`); }
+}
+exports.InvalidPathException = InvalidPathException;
+class PathMustBeAbsoluteException extends core_1.BaseException {
+    constructor(path) { super(`Path ${JSON.stringify(path)} must be absolute.`); }
+}
+exports.PathMustBeAbsoluteException = PathMustBeAbsoluteException;
+/**
+ * The Separator for normalized path.
+ * @type {Path}
+ */
+exports.NormalizedSep = '/';
+/**
+ * The root of a normalized path.
+ * @type {Path}
+ */
+exports.NormalizedRoot = exports.NormalizedSep;
+/**
+ * Split a path into multiple path fragments. Each fragments except the last one will end with
+ * a path separator.
+ * @param {Path} path The path to split.
+ * @returns {Path[]} An array of path fragments.
+ */
+function split(path) {
+    const arr = path.split(exports.NormalizedSep);
+    return arr.map((fragment, i) => fragment + (i < arr.length - 1 ? exports.NormalizedSep : ''));
+}
+exports.split = split;
+/**
+ *
+ */
+function extname(path) {
+    const base = basename(path);
+    const i = base.lastIndexOf('.');
+    if (i < 1) {
+        return '';
+    }
+    else {
+        return base.substr(i);
+    }
+}
+exports.extname = extname;
+/**
+ * This is the equivalent of calling dirname() over and over, until the root, then getting the
+ * basename.
+ *
+ * @example rootname('/a/b/c') == 'a'
+ * @example rootname('a/b') == '.'
+ * @param path The path to get the rootname from.
+ * @returns {Path} The first directory name.
+ */
+function rootname(path) {
+    const i = path.indexOf(exports.NormalizedSep);
+    if (!isAbsolute(path)) {
+        return '.';
+    }
+    else if (i == -1) {
+        return path;
+    }
+    else {
+        return path.substr(path.lastIndexOf(exports.NormalizedSep) + 1);
+    }
+}
+exports.rootname = rootname;
+/**
+ * Return the basename of the path, as a Path. See path.basename
+ */
+function basename(path) {
+    const i = path.lastIndexOf(exports.NormalizedSep);
+    if (i == -1) {
+        return path;
+    }
+    else {
+        return path.substr(path.lastIndexOf(exports.NormalizedSep) + 1);
+    }
+}
+exports.basename = basename;
+/**
+ * Return the dirname of the path, as a Path. See path.dirname
+ */
+function dirname(path) {
+    const i = path.lastIndexOf(exports.NormalizedSep);
+    if (i == -1) {
+        return '';
+    }
+    else {
+        return normalize(path.substr(0, i));
+    }
+}
+exports.dirname = dirname;
+/**
+ * Join multiple paths together, and normalize the result. Accepts strings that will be
+ * normalized as well (but the original must be a path).
+ */
+function join(p1, ...others) {
+    if (others.length > 0) {
+        return normalize((p1 ? p1 + exports.NormalizedSep : '') + others.join(exports.NormalizedSep));
+    }
+    else {
+        return p1;
+    }
+}
+exports.join = join;
+/**
+ * Returns true if a path is absolute.
+ */
+function isAbsolute(p) {
+    return p.startsWith(exports.NormalizedSep);
+}
+exports.isAbsolute = isAbsolute;
+/**
+ * Returns a path such that `join(from, relative(from, to)) == to`.
+ * Both paths must be absolute, otherwise it does not make much sense.
+ */
+function relative(from, to) {
+    if (!isAbsolute(from)) {
+        throw new PathMustBeAbsoluteException(from);
+    }
+    if (!isAbsolute(to)) {
+        throw new PathMustBeAbsoluteException(to);
+    }
+    let p;
+    if (from == to) {
+        p = '';
+    }
+    else {
+        const splitFrom = from.split(exports.NormalizedSep);
+        const splitTo = to.split(exports.NormalizedSep);
+        while (splitFrom.length > 0 && splitTo.length > 0 && splitFrom[0] == splitTo[0]) {
+            splitFrom.shift();
+            splitTo.shift();
+        }
+        if (splitFrom.length == 0) {
+            p = splitTo.join(exports.NormalizedSep);
+        }
+        else {
+            p = splitFrom.map(_ => '..').concat(splitTo).join(exports.NormalizedSep);
+        }
+    }
+    return normalize(p);
+}
+exports.relative = relative;
+/**
+ * Returns a Path that is the resolution of p2, from p1. If p2 is absolute, it will return p2,
+ * otherwise will join both p1 and p2.
+ */
+function resolve(p1, p2) {
+    if (isAbsolute(p2)) {
+        return p2;
+    }
+    else {
+        return join(p1, p2);
+    }
+}
+exports.resolve = resolve;
+/**
+ * Normalize a string into a Path. This is the only mean to get a Path type from a string that
+ * represents a system path. Normalization includes:
+ *   - Windows backslashes `\\` are replaced with `/`.
+ *   - Windows drivers are replaced with `/X/`, where X is the drive letter.
+ *   - Absolute paths starts with `/`.
+ *   - Multiple `/` are replaced by a single one.
+ *   - Path segments `.` are removed.
+ *   - Path segments `..` are resolved.
+ *   - If a path is absolute, having a `..` at the start is invalid (and will throw).
+ */
+function normalize(path) {
+    if (path == '' || path == '.') {
+        return '';
+    }
+    else if (path == exports.NormalizedRoot) {
+        return exports.NormalizedRoot;
+    }
+    // Match absolute windows path.
+    const original = path;
+    if (path.match(/^[A-Z]:\\/)) {
+        path = '\\' + path[0] + '\\' + path.substr(3);
+    }
+    // We convert Windows paths as well here.
+    const p = path.split(/[\/\\]/g);
+    let relative = false;
+    let i = 1;
+    // Special case the first one.
+    if (p[0] != '') {
+        p.unshift('.');
+        relative = true;
+    }
+    while (i < p.length) {
+        if (p[i] == '.') {
+            p.splice(i, 1);
+        }
+        else if (p[i] == '..') {
+            if (i < 2 && !relative) {
+                throw new InvalidPathException(original);
+            }
+            else if (i >= 2 && p[i - 1] != '..') {
+                p.splice(i - 1, 2);
+                i--;
+            }
+            else {
+                i++;
+            }
+        }
+        else if (p[i] == '') {
+            p.splice(i, 1);
+        }
+        else {
+            i++;
+        }
+    }
+    if (p.length == 1) {
+        return p[0] == '' ? exports.NormalizedSep : '';
+    }
+    else {
+        if (p[0] == '.') {
+            p.shift();
+        }
+        return p.join(exports.NormalizedSep);
+    }
+}
+exports.normalize = normalize;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"path.js","sourceRoot":"/Users/hansl/Sources/devkit/","sources":["packages/angular_devkit/core/src/virtual-fs/path.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { BaseException } from '@angular-devkit/core';\n\n\nexport class InvalidPathException extends BaseException {\n  constructor(path: string) { super(`Path ${JSON.stringify(path)} is invalid.`); }\n}\nexport class PathMustBeAbsoluteException extends BaseException {\n  constructor(path: string) { super(`Path ${JSON.stringify(path)} must be absolute.`); }\n}\n\n\n/**\n * A Path recognized by most methods in the DevKit.\n */\nexport type Path = string & {\n  __PRIVATE_DEVKIT_PATH: void;\n};\n\n\n/**\n * The Separator for normalized path.\n * @type {Path}\n */\nexport const NormalizedSep = '/' as Path;\n\n\n/**\n * The root of a normalized path.\n * @type {Path}\n */\nexport const NormalizedRoot = NormalizedSep as Path;\n\n\n/**\n * Split a path into multiple path fragments. Each fragments except the last one will end with\n * a path separator.\n * @param {Path} path The path to split.\n * @returns {Path[]} An array of path fragments.\n */\nexport function split(path: Path): Path[] {\n  const arr = path.split(NormalizedSep);\n\n  return arr.map((fragment, i) => fragment + (i < arr.length - 1 ? NormalizedSep : '')) as Path[];\n}\n\n/**\n *\n */\nexport function extname(path: Path): string {\n  const base = basename(path);\n  const i = base.lastIndexOf('.');\n  if (i < 1) {\n    return '';\n  } else {\n    return base.substr(i);\n  }\n}\n\n/**\n * This is the equivalent of calling dirname() over and over, until the root, then getting the\n * basename.\n *\n * @example rootname('/a/b/c') == 'a'\n * @example rootname('a/b') == '.'\n * @param path The path to get the rootname from.\n * @returns {Path} The first directory name.\n */\nexport function rootname(path: Path): Path {\n  const i = path.indexOf(NormalizedSep);\n  if (!isAbsolute(path)) {\n    return '.' as Path;\n  } else if (i == -1) {\n    return path;\n  } else {\n    return path.substr(path.lastIndexOf(NormalizedSep) + 1) as Path;\n  }\n}\n\n\n/**\n * Return the basename of the path, as a Path. See path.basename\n */\nexport function basename(path: Path): Path {\n  const i = path.lastIndexOf(NormalizedSep);\n  if (i == -1) {\n    return path;\n  } else {\n    return path.substr(path.lastIndexOf(NormalizedSep) + 1) as Path;\n  }\n}\n\n\n/**\n * Return the dirname of the path, as a Path. See path.dirname\n */\nexport function dirname(path: Path): Path {\n  const i = path.lastIndexOf(NormalizedSep);\n  if (i == -1) {\n    return '' as Path;\n  } else {\n    return normalize(path.substr(0, i));\n  }\n}\n\n\n/**\n * Join multiple paths together, and normalize the result. Accepts strings that will be\n * normalized as well (but the original must be a path).\n */\nexport function join(p1: Path, ...others: string[]): Path {\n  if (others.length > 0) {\n    return normalize((p1 ? p1 + NormalizedSep : '') + others.join(NormalizedSep));\n  } else {\n    return p1;\n  }\n}\n\n\n/**\n * Returns true if a path is absolute.\n */\nexport function isAbsolute(p: Path) {\n  return p.startsWith(NormalizedSep);\n}\n\n\n/**\n * Returns a path such that `join(from, relative(from, to)) == to`.\n * Both paths must be absolute, otherwise it does not make much sense.\n */\nexport function relative(from: Path, to: Path): Path {\n  if (!isAbsolute(from)) {\n    throw new PathMustBeAbsoluteException(from);\n  }\n  if (!isAbsolute(to)) {\n    throw new PathMustBeAbsoluteException(to);\n  }\n\n  let p: string;\n\n  if (from == to) {\n    p = '';\n  } else {\n    const splitFrom = from.split(NormalizedSep);\n    const splitTo = to.split(NormalizedSep);\n\n    while (splitFrom.length > 0 && splitTo.length > 0 && splitFrom[0] == splitTo[0]) {\n      splitFrom.shift();\n      splitTo.shift();\n    }\n\n    if (splitFrom.length == 0) {\n      p = splitTo.join(NormalizedSep);\n    } else {\n      p = splitFrom.map(_ => '..').concat(splitTo).join(NormalizedSep);\n    }\n  }\n\n  return normalize(p);\n}\n\n\n/**\n * Returns a Path that is the resolution of p2, from p1. If p2 is absolute, it will return p2,\n * otherwise will join both p1 and p2.\n */\nexport function resolve(p1: Path, p2: Path) {\n  if (isAbsolute(p2)) {\n    return p2;\n  } else {\n    return join(p1, p2);\n  }\n}\n\n\n/**\n * Normalize a string into a Path. This is the only mean to get a Path type from a string that\n * represents a system path. Normalization includes:\n *   - Windows backslashes `\\\\` are replaced with `/`.\n *   - Windows drivers are replaced with `/X/`, where X is the drive letter.\n *   - Absolute paths starts with `/`.\n *   - Multiple `/` are replaced by a single one.\n *   - Path segments `.` are removed.\n *   - Path segments `..` are resolved.\n *   - If a path is absolute, having a `..` at the start is invalid (and will throw).\n */\nexport function normalize(path: string): Path {\n  if (path == '' || path == '.') {\n    return '' as Path;\n  } else if (path == NormalizedRoot) {\n    return NormalizedRoot;\n  }\n\n  // Match absolute windows path.\n  const original = path;\n  if (path.match(/^[A-Z]:\\\\/)) {\n    path = '\\\\' + path[0] + '\\\\' + path.substr(3);\n  }\n\n  // We convert Windows paths as well here.\n  const p = path.split(/[\\/\\\\]/g);\n  let relative = false;\n  let i = 1;\n\n  // Special case the first one.\n  if (p[0] != '') {\n    p.unshift('.');\n    relative = true;\n  }\n\n  while (i < p.length) {\n    if (p[i] == '.') {\n      p.splice(i, 1);\n    } else if (p[i] == '..') {\n      if (i < 2 && !relative) {\n        throw new InvalidPathException(original);\n      } else if (i >= 2 && p[i - 1] != '..') {\n        p.splice(i - 1, 2);\n        i--;\n      } else {\n        i++;\n      }\n    } else if (p[i] == '') {\n      p.splice(i, 1);\n    } else {\n      i++;\n    }\n  }\n\n  if (p.length == 1) {\n    return p[0] == '' ? NormalizedSep : '' as Path;\n  } else {\n    if (p[0] == '.') {\n      p.shift();\n    }\n\n    return p.join(NormalizedSep) as Path;\n  }\n}\n"]}

package/src/virtual-fs/path_benchmark.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const benchmark_1 = require("@_/benchmark");
+const path_1 = require("./path");
+const p1 = '/b/././a/tt/../../../a/b/./d/../c';
+const p2 = '/a/tt/../../../a/b/./d';
+describe('Virtual FS Path', () => {
+    benchmark_1.benchmark('normalize', () => path_1.normalize(p1));
+    benchmark_1.benchmark('join', () => path_1.join(path_1.normalize(p1), path_1.normalize(p2)));
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aF9iZW5jaG1hcmsuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvdmlydHVhbC1mcy9wYXRoX2JlbmNobWFyay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBOzs7Ozs7R0FNRztBQUNILDRDQUF5QztBQUN6QyxpQ0FBeUM7QUFHekMsTUFBTSxFQUFFLEdBQUcsbUNBQW1DLENBQUM7QUFDL0MsTUFBTSxFQUFFLEdBQUcsd0JBQXdCLENBQUM7QUFHcEMsUUFBUSxDQUFDLGlCQUFpQixFQUFFO0lBQzFCLHFCQUFTLENBQUMsV0FBVyxFQUFFLE1BQU0sZ0JBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzVDLHFCQUFTLENBQUMsTUFBTSxFQUFFLE1BQU0sV0FBSSxDQUFDLGdCQUFTLENBQUMsRUFBRSxDQUFDLEVBQUUsZ0JBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDOUQsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQgeyBiZW5jaG1hcmsgfSBmcm9tICdAXy9iZW5jaG1hcmsnO1xuaW1wb3J0IHsgam9pbiwgbm9ybWFsaXplIH0gZnJvbSAnLi9wYXRoJztcblxuXG5jb25zdCBwMSA9ICcvYi8uLy4vYS90dC8uLi8uLi8uLi9hL2IvLi9kLy4uL2MnO1xuY29uc3QgcDIgPSAnL2EvdHQvLi4vLi4vLi4vYS9iLy4vZCc7XG5cblxuZGVzY3JpYmUoJ1ZpcnR1YWwgRlMgUGF0aCcsICgpID0+IHtcbiAgYmVuY2htYXJrKCdub3JtYWxpemUnLCAoKSA9PiBub3JtYWxpemUocDEpKTtcbiAgYmVuY2htYXJrKCdqb2luJywgKCkgPT4gam9pbihub3JtYWxpemUocDEpLCBub3JtYWxpemUocDIpKSk7XG59KTtcbiJdfQ==

package/src/logger/cli-logger.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-require("rxjs/add/operator/filter");
-const terminal_1 = require("../terminal");
-const indent_1 = require("./indent");
-/**
- * A Logger that sends information to STDOUT and STDERR.
- */
-function createLogger(verbose = false) {
-    const logger = new indent_1.IndentLogger('cling');
-    logger
-        .filter((entry) => (entry.level != 'debug' || verbose))
-        .subscribe((entry) => {
-        let color = x => terminal_1.dim(terminal_1.white(x));
-        let output = process.stdout;
-        switch (entry.level) {
-            case 'info':
-                color = terminal_1.white;
-                break;
-            case 'warn':
-                color = terminal_1.yellow;
-                break;
-            case 'error':
-                color = terminal_1.red;
-                output = process.stderr;
-                break;
-            case 'fatal':
-                color = (x) => terminal_1.bold(terminal_1.red(x));
-                output = process.stderr;
-                break;
-        }
-        output.write(color(entry.message) + '\n');
-    });
-    return logger;
-}
-exports.createLogger = createLogger;
-//# sourceMappingURL=data:application/json;base64,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