mirror of
https://github.com/denoland/deno.git
synced 2024-12-12 18:42:18 -05:00
ce75e31625
This commit changes "include_js_files!" macro from "deno_core" in a way that "dir" option doesn't cause specifiers to be rewritten to include it. Example: ``` include_js_files! { dir "js", "hello.js", } ``` The above definition required embedders to use: `import ... from "internal:<ext_name>/js/hello.js"`. But with this change, the "js" directory in which the files are stored is an implementation detail, which for embedders results in: `import ... from "internal:<ext_name>/hello.js"`. The directory the files are stored in, is an implementation detail and in some cases might result in a significant size difference for the snapshot. As an example, in "deno_node" extension, we store the source code in "polyfills" directory; which resulted in each specifier to look like "internal:deno_node/polyfills/<module_name>", but with this change it's "internal:deno_node/<module_name>". Given that "deno_node" has over 100 files, many of them having several import specifiers to the same extension, this change removes 10 characters from each import specifier.
536 lines
15 KiB
TypeScript
536 lines
15 KiB
TypeScript
// Copyright the Browserify authors. MIT License.
|
|
// Ported from https://github.com/browserify/path-browserify/
|
|
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
|
|
|
import type {
|
|
FormatInputPathObject,
|
|
ParsedPath,
|
|
} from "internal:deno_node/path/_interface.ts";
|
|
import {
|
|
CHAR_DOT,
|
|
CHAR_FORWARD_SLASH,
|
|
} from "internal:deno_node/path/_constants.ts";
|
|
import { ERR_INVALID_ARG_TYPE } from "internal:deno_node/internal/errors.ts";
|
|
|
|
import {
|
|
_format,
|
|
assertPath,
|
|
encodeWhitespace,
|
|
isPosixPathSeparator,
|
|
normalizeString,
|
|
} from "internal:deno_node/path/_util.ts";
|
|
|
|
export const sep = "/";
|
|
export const delimiter = ":";
|
|
|
|
// path.resolve([from ...], to)
|
|
/**
|
|
* Resolves `pathSegments` into an absolute path.
|
|
* @param pathSegments an array of path segments
|
|
*/
|
|
export function resolve(...pathSegments: string[]): string {
|
|
let resolvedPath = "";
|
|
let resolvedAbsolute = false;
|
|
|
|
for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
let path: string;
|
|
|
|
if (i >= 0) path = pathSegments[i];
|
|
else {
|
|
// deno-lint-ignore no-explicit-any
|
|
const { Deno } = globalThis as any;
|
|
if (typeof Deno?.cwd !== "function") {
|
|
throw new TypeError("Resolved a relative path without a CWD.");
|
|
}
|
|
path = Deno.cwd();
|
|
}
|
|
|
|
assertPath(path);
|
|
|
|
// Skip empty entries
|
|
if (path.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
resolvedPath = `${path}/${resolvedPath}`;
|
|
resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
}
|
|
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
|
|
// Normalize the path
|
|
resolvedPath = normalizeString(
|
|
resolvedPath,
|
|
!resolvedAbsolute,
|
|
"/",
|
|
isPosixPathSeparator,
|
|
);
|
|
|
|
if (resolvedAbsolute) {
|
|
if (resolvedPath.length > 0) return `/${resolvedPath}`;
|
|
else return "/";
|
|
} else if (resolvedPath.length > 0) return resolvedPath;
|
|
else return ".";
|
|
}
|
|
|
|
/**
|
|
* Normalize the `path`, resolving `'..'` and `'.'` segments.
|
|
* @param path to be normalized
|
|
*/
|
|
export function normalize(path: string): string {
|
|
assertPath(path);
|
|
|
|
if (path.length === 0) return ".";
|
|
|
|
const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
const trailingSeparator =
|
|
path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
|
|
|
|
// Normalize the path
|
|
path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
|
|
|
|
if (path.length === 0 && !isAbsolute) path = ".";
|
|
if (path.length > 0 && trailingSeparator) path += "/";
|
|
|
|
if (isAbsolute) return `/${path}`;
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* Verifies whether provided path is absolute
|
|
* @param path to be verified as absolute
|
|
*/
|
|
export function isAbsolute(path: string): boolean {
|
|
assertPath(path);
|
|
return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
}
|
|
|
|
/**
|
|
* Join all given a sequence of `paths`,then normalizes the resulting path.
|
|
* @param paths to be joined and normalized
|
|
*/
|
|
export function join(...paths: string[]): string {
|
|
if (paths.length === 0) return ".";
|
|
let joined: string | undefined;
|
|
for (let i = 0, len = paths.length; i < len; ++i) {
|
|
const path = paths[i];
|
|
assertPath(path);
|
|
if (path.length > 0) {
|
|
if (!joined) joined = path;
|
|
else joined += `/${path}`;
|
|
}
|
|
}
|
|
if (!joined) return ".";
|
|
return normalize(joined);
|
|
}
|
|
|
|
/**
|
|
* Return the relative path from `from` to `to` based on current working directory.
|
|
* @param from path in current working directory
|
|
* @param to path in current working directory
|
|
*/
|
|
export function relative(from: string, to: string): string {
|
|
assertPath(from);
|
|
assertPath(to);
|
|
|
|
if (from === to) return "";
|
|
|
|
from = resolve(from);
|
|
to = resolve(to);
|
|
|
|
if (from === to) return "";
|
|
|
|
// Trim any leading backslashes
|
|
let fromStart = 1;
|
|
const fromEnd = from.length;
|
|
for (; fromStart < fromEnd; ++fromStart) {
|
|
if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;
|
|
}
|
|
const fromLen = fromEnd - fromStart;
|
|
|
|
// Trim any leading backslashes
|
|
let toStart = 1;
|
|
const toEnd = to.length;
|
|
for (; toStart < toEnd; ++toStart) {
|
|
if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;
|
|
}
|
|
const toLen = toEnd - toStart;
|
|
|
|
// Compare paths to find the longest common path from root
|
|
const length = fromLen < toLen ? fromLen : toLen;
|
|
let lastCommonSep = -1;
|
|
let i = 0;
|
|
for (; i <= length; ++i) {
|
|
if (i === length) {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
|
|
// We get here if `from` is the exact base path for `to`.
|
|
// For example: from='/foo/bar'; to='/foo/bar/baz'
|
|
return to.slice(toStart + i + 1);
|
|
} else if (i === 0) {
|
|
// We get here if `from` is the root
|
|
// For example: from='/'; to='/foo'
|
|
return to.slice(toStart + i);
|
|
}
|
|
} else if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
|
|
// We get here if `to` is the exact base path for `from`.
|
|
// For example: from='/foo/bar/baz'; to='/foo/bar'
|
|
lastCommonSep = i;
|
|
} else if (i === 0) {
|
|
// We get here if `to` is the root.
|
|
// For example: from='/foo'; to='/'
|
|
lastCommonSep = 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
const fromCode = from.charCodeAt(fromStart + i);
|
|
const toCode = to.charCodeAt(toStart + i);
|
|
if (fromCode !== toCode) break;
|
|
else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
|
|
}
|
|
|
|
let out = "";
|
|
// Generate the relative path based on the path difference between `to`
|
|
// and `from`
|
|
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
|
|
if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (out.length === 0) out += "..";
|
|
else out += "/..";
|
|
}
|
|
}
|
|
|
|
// Lastly, append the rest of the destination (`to`) path that comes after
|
|
// the common path parts
|
|
if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
|
|
else {
|
|
toStart += lastCommonSep;
|
|
if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;
|
|
return to.slice(toStart);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolves path to a namespace path
|
|
* @param path to resolve to namespace
|
|
*/
|
|
export function toNamespacedPath(path: string): string {
|
|
// Non-op on posix systems
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* Return the directory name of a `path`.
|
|
* @param path to determine name for
|
|
*/
|
|
export function dirname(path: string): string {
|
|
assertPath(path);
|
|
if (path.length === 0) return ".";
|
|
const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
for (let i = path.length - 1; i >= 1; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
// We saw the first non-path separator
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
|
|
if (end === -1) return hasRoot ? "/" : ".";
|
|
if (hasRoot && end === 1) return "//";
|
|
return path.slice(0, end);
|
|
}
|
|
|
|
/**
|
|
* Return the last portion of a `path`. Trailing directory separators are ignored.
|
|
* @param path to process
|
|
* @param ext of path directory
|
|
*/
|
|
export function basename(path: string, ext = ""): string {
|
|
if (ext !== undefined && typeof ext !== "string") {
|
|
throw new ERR_INVALID_ARG_TYPE("ext", ["string"], ext);
|
|
}
|
|
assertPath(path);
|
|
|
|
let start = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let i: number;
|
|
|
|
if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
|
|
if (ext.length === path.length && ext === path) return "";
|
|
let extIdx = ext.length - 1;
|
|
let firstNonSlashEnd = -1;
|
|
for (i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
// We saw the first non-path separator, remember this index in case
|
|
// we need it if the extension ends up not matching
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
// Try to match the explicit extension
|
|
if (code === ext.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) {
|
|
// We matched the extension, so mark this as the end of our path
|
|
// component
|
|
end = i;
|
|
}
|
|
} else {
|
|
// Extension does not match, so our result is the entire path
|
|
// component
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.slice(start, end);
|
|
} else {
|
|
for (i = path.length - 1; i >= 0; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// path component
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
|
|
if (end === -1) return "";
|
|
return path.slice(start, end);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the extension of the `path`.
|
|
* @param path with extension
|
|
*/
|
|
export function extname(path: string): string {
|
|
assertPath(path);
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
// Track the state of characters (if any) we see before our first dot and
|
|
// after any path separator we find
|
|
let preDotState = 0;
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// extension
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
// If this is our first dot, mark it as the start of our extension
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
// We saw a non-dot and non-path separator before our dot, so we should
|
|
// have a good chance at having a non-empty extension
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
|
|
if (
|
|
startDot === -1 ||
|
|
end === -1 ||
|
|
// We saw a non-dot character immediately before the dot
|
|
preDotState === 0 ||
|
|
// The (right-most) trimmed path component is exactly '..'
|
|
(preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
|
|
) {
|
|
return "";
|
|
}
|
|
return path.slice(startDot, end);
|
|
}
|
|
|
|
/**
|
|
* Generate a path from `FormatInputPathObject` object.
|
|
* @param pathObject with path
|
|
*/
|
|
export function format(pathObject: FormatInputPathObject): string {
|
|
if (pathObject === null || typeof pathObject !== "object") {
|
|
throw new ERR_INVALID_ARG_TYPE("pathObject", ["Object"], pathObject);
|
|
}
|
|
return _format("/", pathObject);
|
|
}
|
|
|
|
/**
|
|
* Return a `ParsedPath` object of the `path`.
|
|
* @param path to process
|
|
*/
|
|
export function parse(path: string): ParsedPath {
|
|
assertPath(path);
|
|
|
|
const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" };
|
|
if (path.length === 0) return ret;
|
|
const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
let start: number;
|
|
if (isAbsolute) {
|
|
ret.root = "/";
|
|
start = 1;
|
|
} else {
|
|
start = 0;
|
|
}
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let i = path.length - 1;
|
|
|
|
// Track the state of characters (if any) we see before our first dot and
|
|
// after any path separator we find
|
|
let preDotState = 0;
|
|
|
|
// Get non-dir info
|
|
for (; i >= start; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// extension
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
// If this is our first dot, mark it as the start of our extension
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
// We saw a non-dot and non-path separator before our dot, so we should
|
|
// have a good chance at having a non-empty extension
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
|
|
if (
|
|
startDot === -1 ||
|
|
end === -1 ||
|
|
// We saw a non-dot character immediately before the dot
|
|
preDotState === 0 ||
|
|
// The (right-most) trimmed path component is exactly '..'
|
|
(preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
|
|
) {
|
|
if (end !== -1) {
|
|
if (startPart === 0 && isAbsolute) {
|
|
ret.base = ret.name = path.slice(1, end);
|
|
} else {
|
|
ret.base = ret.name = path.slice(startPart, end);
|
|
}
|
|
}
|
|
} else {
|
|
if (startPart === 0 && isAbsolute) {
|
|
ret.name = path.slice(1, startDot);
|
|
ret.base = path.slice(1, end);
|
|
} else {
|
|
ret.name = path.slice(startPart, startDot);
|
|
ret.base = path.slice(startPart, end);
|
|
}
|
|
ret.ext = path.slice(startDot, end);
|
|
}
|
|
|
|
if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
|
|
else if (isAbsolute) ret.dir = "/";
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Converts a file URL to a path string.
|
|
*
|
|
* ```ts
|
|
* fromFileUrl("file:///home/foo"); // "/home/foo"
|
|
* ```
|
|
* @param url of a file URL
|
|
*/
|
|
export function fromFileUrl(url: string | URL): string {
|
|
url = url instanceof URL ? url : new URL(url);
|
|
if (url.protocol != "file:") {
|
|
throw new TypeError("Must be a file URL.");
|
|
}
|
|
return decodeURIComponent(
|
|
url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Converts a path string to a file URL.
|
|
*
|
|
* ```ts
|
|
* toFileUrl("/home/foo"); // new URL("file:///home/foo")
|
|
* ```
|
|
* @param path to convert to file URL
|
|
*/
|
|
export function toFileUrl(path: string): URL {
|
|
if (!isAbsolute(path)) {
|
|
throw new TypeError("Must be an absolute path.");
|
|
}
|
|
const url = new URL("file:///");
|
|
url.pathname = encodeWhitespace(
|
|
path.replace(/%/g, "%25").replace(/\\/g, "%5C"),
|
|
);
|
|
return url;
|
|
}
|
|
|
|
export default {
|
|
basename,
|
|
delimiter,
|
|
dirname,
|
|
extname,
|
|
format,
|
|
fromFileUrl,
|
|
isAbsolute,
|
|
join,
|
|
normalize,
|
|
parse,
|
|
relative,
|
|
resolve,
|
|
sep,
|
|
toFileUrl,
|
|
toNamespacedPath,
|
|
};
|