polymer-bundler/lib/url-utils.js

Process Web Components into one output file

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * @license
 * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
const path = require("path");
const url = require("url");
const vscode_uri_1 = require("vscode-uri");
const constants_1 = require("./constants");
/**
 * Produce a version of the URL provided with the given extension concatenated
 * to the path. Example:
 *     appendUrlPath('file:///something/something.html?ponies', '_omg.js')
 * Produces:
 *     'file:///something/something.html_omg.js?ponies'
 */
function appendUrlPath(url, extension) {
    const { scheme, authority, path, query, fragment } = vscode_uri_1.default.parse(url);
    return vscode_uri_1.default.from({ scheme, authority, path: path + extension, query, fragment })
        .toString();
}
exports.appendUrlPath = appendUrlPath;
/**
 * Given a string representing a relative path of some form, ensure a `./`
 * leader if it doesn't already start with dot-based path leader or a scheme
 * (like, you wouldn't want to change `file:///example.js` into
 * `./file:///example.js`)
 */
function ensureLeadingDot(href) {
    if (!vscode_uri_1.default.parse(href).scheme &&
        !(href.startsWith('./') || href.startsWith('../'))) {
        return './' + href;
    }
    return href;
}
exports.ensureLeadingDot = ensureLeadingDot;
/**
 * Given a string representing a URL or path of some form, append a `/`
 * character if it doesn't already end with one.
 */
function ensureTrailingSlash(href) {
    return href.endsWith('/') ? href : (href + '/');
}
exports.ensureTrailingSlash = ensureTrailingSlash;
/**
 * Parses the URL and returns the extname of the path.
 */
function getFileExtension(url_) {
    return path.extname(getFileName(url_));
}
exports.getFileExtension = getFileExtension;
/**
 * Parses the URL and returns only the filename part of the path.
 */
function getFileName(url_) {
    const uri = vscode_uri_1.default.parse(url_);
    return uri.path.split(/\//).pop() || '';
}
exports.getFileName = getFileName;
/**
 * Returns a WHATWG ResolvedURL for a filename on local filesystem.
 */
function getFileUrl(filename) {
    return vscode_uri_1.default.file(resolvePath(filename)).toString();
}
exports.getFileUrl = getFileUrl;
/**
 * Returns a URL with the basename removed from the pathname.  Strips the
 * search off of the URL as well, since it will not apply.
 */
function stripUrlFileSearchAndHash(href) {
    const u = url.parse(href);
    // Using != so tests for null AND undefined
    if (u.pathname != null) {
        // Suffix path with `_` so that `/a/b/` is treated as `/a/b/_` and that
        // `path.posix.dirname()` returns `/a/b` because it would otherwise
        // return `/a` incorrectly.
        u.pathname = ensureTrailingSlash(path.posix.dirname(u.pathname + '_'));
    }
    // Assigning to undefined because TSC says type of these is
    // `string | undefined` as opposed to `string | null`
    u.search = undefined;
    u.hash = undefined;
    return url.format(u);
}
exports.stripUrlFileSearchAndHash = stripUrlFileSearchAndHash;
/**
 * Returns true if the href is an absolute path.
 */
function isAbsolutePath(href) {
    return constants_1.default.ABS_URL.test(href);
}
exports.isAbsolutePath = isAbsolutePath;
/**
 * Returns true if the href is a templated value, i.e. `{{...}}` or `[[...]]`
 */
function isTemplatedUrl(href) {
    return href.search(constants_1.default.URL_TEMPLATE) >= 0;
}
exports.isTemplatedUrl = isTemplatedUrl;
/**
 * The path library's resolve function drops the trailing slash from the input
 * when returning the result.  This is bad because clients of the function then
 * have to ensure it is reapplied conditionally.  This function resolves the
 * input path while preserving the trailing slash, when present.
 */
function resolvePath(...segments) {
    if (segments.length === 0) {
        // Special cwd case
        return ensureTrailingSlash(path.resolve());
    }
    const lastSegment = segments[segments.length - 1];
    const resolved = path.resolve(...segments);
    return lastSegment.endsWith('/') ? ensureTrailingSlash(resolved) : resolved;
}
exports.resolvePath = resolvePath;
//# sourceMappingURL=url-utils.js.map