File size: 4,729 Bytes
bc20498 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 |
import fs from 'node:fs';
import path from 'node:path';
/** @param {string} dir */
export function mkdirp(dir) {
try {
fs.mkdirSync(dir, { recursive: true });
} catch (/** @type {any} */ e) {
if (e.code === 'EEXIST') {
if (!fs.statSync(dir).isDirectory()) {
throw new Error(`Cannot create directory ${dir}, a file already exists at this position`);
}
return;
}
throw e;
}
}
/** @param {string} path */
export function rimraf(path) {
fs.rmSync(path, { force: true, recursive: true });
}
/**
* @param {string} source
* @param {string} target
* @param {{
* filter?: (basename: string) => boolean;
* replace?: Record<string, string>;
* }} opts
*/
export function copy(source, target, opts = {}) {
if (!fs.existsSync(source)) return [];
/** @type {string[]} */
const files = [];
const prefix = posixify(target) + '/';
const regex = opts.replace
? new RegExp(`\\b(${Object.keys(opts.replace).join('|')})\\b`, 'g')
: null;
/**
* @param {string} from
* @param {string} to
*/
function go(from, to) {
if (opts.filter && !opts.filter(path.basename(from))) return;
const stats = fs.statSync(from);
if (stats.isDirectory()) {
fs.readdirSync(from).forEach((file) => {
go(path.join(from, file), path.join(to, file));
});
} else {
mkdirp(path.dirname(to));
if (opts.replace) {
const data = fs.readFileSync(from, 'utf-8');
fs.writeFileSync(
to,
data.replace(
/** @type {RegExp} */ (regex),
(_match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
)
);
} else {
fs.copyFileSync(from, to);
}
files.push(to === target ? posixify(path.basename(to)) : posixify(to).replace(prefix, ''));
}
}
go(source, target);
return files;
}
/**
* Get a list of all files in a directory
* @param {string} cwd - the directory to walk
* @param {boolean} [dirs] - whether to include directories in the result
* @returns {string[]} a list of all found files (and possibly directories) relative to `cwd`
*/
export function walk(cwd, dirs = false) {
/** @type {string[]} */
const all_files = [];
/** @param {string} dir */
function walk_dir(dir) {
const files = fs.readdirSync(path.join(cwd, dir));
for (const file of files) {
const joined = path.join(dir, file);
const stats = fs.statSync(path.join(cwd, joined));
if (stats.isDirectory()) {
if (dirs) all_files.push(joined);
walk_dir(joined);
} else {
all_files.push(joined);
}
}
}
return walk_dir(''), all_files;
}
/** @param {string} str */
export function posixify(str) {
return str.replace(/\\/g, '/');
}
/**
* Like `path.join`, but posixified and with a leading `./` if necessary
* @param {string[]} str
*/
export function join_relative(...str) {
let result = posixify(path.join(...str));
if (!result.startsWith('.')) {
result = `./${result}`;
}
return result;
}
/**
* Like `path.relative`, but always posixified and with a leading `./` if necessary.
* Useful for JS imports so the path can safely reside inside of `node_modules`.
* Otherwise paths could be falsely interpreted as package paths.
* @param {string} from
* @param {string} to
*/
export function relative_path(from, to) {
return join_relative(path.relative(from, to));
}
/**
* Prepend given path with `/@fs` prefix
* @param {string} str
*/
export function to_fs(str) {
str = posixify(str);
return `/@fs${
// Windows/Linux separation - Windows starts with a drive letter, we need a / in front there
str.startsWith('/') ? '' : '/'
}${str}`;
}
/**
* Removes `/@fs` prefix from given path and posixifies it
* @param {string} str
*/
export function from_fs(str) {
str = posixify(str);
if (!str.startsWith('/@fs')) return str;
str = str.slice(4);
// Windows/Linux separation - Windows starts with a drive letter, we need to strip the additional / here
return str[2] === ':' && /[A-Z]/.test(str[1]) ? str.slice(1) : str;
}
/**
* Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
* @param {string} entry
* @returns {string|null}
*/
export function resolve_entry(entry) {
if (fs.existsSync(entry)) {
const stats = fs.statSync(entry);
if (stats.isDirectory()) {
return resolve_entry(path.join(entry, 'index'));
}
return entry;
} else {
const dir = path.dirname(entry);
if (fs.existsSync(dir)) {
const base = path.basename(entry);
const files = fs.readdirSync(dir);
const found = files.find((file) => file.replace(/\.(js|ts)$/, '') === base);
if (found) return path.join(dir, found);
}
}
return null;
}
/** @param {string} file */
export function read(file) {
return fs.readFileSync(file, 'utf-8');
}
|