"use strict";
|
/* eslint-disable require-atomic-updates */
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
if (k2 === undefined) k2 = k;
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
}
|
Object.defineProperty(o, k2, desc);
|
}) : (function(o, m, k, k2) {
|
if (k2 === undefined) k2 = k;
|
o[k2] = m[k];
|
}));
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
}) : function(o, v) {
|
o["default"] = v;
|
});
|
var __importStar = (this && this.__importStar) || function (mod) {
|
if (mod && mod.__esModule) return mod;
|
var result = {};
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
__setModuleDefault(result, mod);
|
return result;
|
};
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
};
|
Object.defineProperty(exports, "__esModule", { value: true });
|
const assert_1 = __importDefault(require("assert"));
|
const fs_extra_1 = __importDefault(require("fs-extra"));
|
const is_core_module_1 = __importDefault(require("is-core-module"));
|
const globby_1 = __importDefault(require("globby"));
|
const path_1 = __importDefault(require("path"));
|
const chalk_1 = __importDefault(require("chalk"));
|
const common_1 = require("./common");
|
const follow_1 = require("./follow");
|
const log_1 = require("./log");
|
const detector = __importStar(require("./detector"));
|
// Note: as a developer, you can set the PKG_STRICT_VER variable.
|
// this will turn on some assertion in the walker code below
|
// to assert that each file content/state that we appending
|
// to the virtual file system applies to a real file,
|
// not a symlink.
|
// By default assertion are disabled as they can have a
|
// performance hit.
|
const strictVerify = Boolean(process.env.PKG_STRICT_VER);
|
const win32 = process.platform === 'win32';
|
function unlikelyJavascript(file) {
|
return ['.css', '.html', '.json', '.vue'].includes(path_1.default.extname(file));
|
}
|
function isPublic(config) {
|
if (config.private) {
|
return false;
|
}
|
const { licenses } = config;
|
let { license } = config;
|
if (licenses) {
|
license = licenses;
|
}
|
if (license && !Array.isArray(license)) {
|
license = typeof license === 'string' ? license : license.type;
|
}
|
if (Array.isArray(license)) {
|
license = license.map((c) => String(c.type || c)).join(',');
|
}
|
if (!license) {
|
return false;
|
}
|
if (/^\(/.test(license)) {
|
license = license.slice(1);
|
}
|
if (/\)$/.test(license)) {
|
license = license.slice(0, -1);
|
}
|
license = license.toLowerCase();
|
const allLicenses = Array.prototype.concat(license.split(' or '), license.split(' and '), license.split('/'), license.split(','));
|
let result = false;
|
const foss = [
|
'isc',
|
'mit',
|
'apache-2.0',
|
'apache 2.0',
|
'public domain',
|
'bsd',
|
'bsd-2-clause',
|
'bsd-3-clause',
|
'wtfpl',
|
'cc-by-3.0',
|
'x11',
|
'artistic-2.0',
|
'gplv3',
|
'mpl',
|
'mplv2.0',
|
'unlicense',
|
'apache license 2.0',
|
'zlib',
|
'mpl-2.0',
|
'nasa-1.3',
|
'apache license, version 2.0',
|
'lgpl-2.1+',
|
'cc0-1.0',
|
];
|
for (const c of allLicenses) {
|
result = foss.indexOf(c) >= 0;
|
if (result) {
|
break;
|
}
|
}
|
return result;
|
}
|
function upon(p, base) {
|
if (typeof p !== 'string') {
|
throw (0, log_1.wasReported)('Config items must be strings. See examples');
|
}
|
let negate = false;
|
if (p[0] === '!') {
|
p = p.slice(1);
|
negate = true;
|
}
|
p = path_1.default.join(base, p);
|
if (win32) {
|
p = p.replace(/\\/g, '/');
|
}
|
if (negate) {
|
p = `!${p}`;
|
}
|
return p;
|
}
|
function collect(ps) {
|
return globby_1.default.sync(ps, { dot: true });
|
}
|
function expandFiles(efs, base) {
|
if (!Array.isArray(efs)) {
|
efs = [efs];
|
}
|
efs = collect(efs.map((p) => upon(p, base)));
|
return efs;
|
}
|
async function stepRead(record) {
|
if (strictVerify) {
|
(0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file));
|
}
|
let body;
|
try {
|
body = await fs_extra_1.default.readFile(record.file);
|
}
|
catch (error) {
|
const exception = error;
|
log_1.log.error(`Cannot read file, ${exception.code}`, record.file);
|
throw (0, log_1.wasReported)(exception.message);
|
}
|
record.body = body;
|
}
|
function stepStrip(record) {
|
let body = (record.body || '').toString('utf8');
|
if (/^\ufeff/.test(body)) {
|
body = body.replace(/^\ufeff/, '');
|
}
|
if (/^#!/.test(body)) {
|
body = body.replace(/^#![^\n]*\n/, '\n');
|
}
|
record.body = body;
|
}
|
function stepDetect(record, marker, derivatives) {
|
let { body = '' } = record;
|
if (body instanceof Buffer) {
|
body = body.toString();
|
}
|
try {
|
detector.detect(body, (node, trying) => {
|
const { toplevel } = marker;
|
let d = detector.visitorSuccessful(node);
|
if (d) {
|
if (d.mustExclude) {
|
return false;
|
}
|
d.mayExclude = d.mayExclude || trying;
|
derivatives.push(d);
|
return false;
|
}
|
d = detector.visitorNonLiteral(node);
|
if (d) {
|
if (typeof d === 'object' && d.mustExclude) {
|
return false;
|
}
|
const debug = !toplevel || d.mayExclude || trying;
|
const level = debug ? 'debug' : 'warn';
|
log_1.log[level](`Cannot resolve '${d.alias}'`, [
|
record.file,
|
'Dynamic require may fail at run time, because the requested file',
|
'is unknown at compilation time and not included into executable.',
|
"Use a string literal as an argument for 'require', or leave it",
|
"as is and specify the resolved file name in 'scripts' option.",
|
]);
|
return false;
|
}
|
d = detector.visitorMalformed(node);
|
if (d) {
|
// there is no 'mustExclude'
|
const debug = !toplevel || trying;
|
const level = debug ? 'debug' : 'warn'; // there is no 'mayExclude'
|
log_1.log[level](`Malformed requirement for '${d.alias}'`, [record.file]);
|
return false;
|
}
|
d = detector.visitorUseSCWD(node);
|
if (d) {
|
// there is no 'mustExclude'
|
const level = 'debug'; // there is no 'mayExclude'
|
log_1.log[level](`Path.resolve(${d.alias}) is ambiguous`, [
|
record.file,
|
"It resolves relatively to 'process.cwd' by default, however",
|
"you may want to use 'path.dirname(require.main.filename)'",
|
]);
|
return false;
|
}
|
return true; // can i go inside?
|
});
|
}
|
catch (error) {
|
log_1.log.error(error.message, record.file);
|
throw (0, log_1.wasReported)(error.message);
|
}
|
}
|
function findCommonJunctionPoint(file, realFile) {
|
// find common denominator => where the link changes
|
while ((0, common_1.toNormalizedRealPath)(path_1.default.dirname(file)) === path_1.default.dirname(realFile)) {
|
file = path_1.default.dirname(file);
|
realFile = path_1.default.dirname(realFile);
|
}
|
return { file, realFile };
|
}
|
class Walker {
|
constructor() {
|
this.tasks = [];
|
this.records = {};
|
this.dictionary = {};
|
this.patches = {};
|
this.params = {};
|
this.symLinks = {};
|
}
|
appendRecord({ file, store }) {
|
if (this.records[file]) {
|
return;
|
}
|
if (store === common_1.STORE_BLOB ||
|
store === common_1.STORE_CONTENT ||
|
store === common_1.STORE_LINKS) {
|
// make sure we have a real file
|
if (strictVerify) {
|
(0, assert_1.default)(file === (0, common_1.toNormalizedRealPath)(file));
|
}
|
}
|
this.records[file] = { file };
|
}
|
append(task) {
|
if (strictVerify) {
|
(0, assert_1.default)(typeof task.file === 'string');
|
(0, assert_1.default)(task.file === (0, common_1.normalizePath)(task.file));
|
}
|
this.appendRecord(task);
|
this.tasks.push(task);
|
const what = {
|
[common_1.STORE_BLOB]: 'Bytecode of',
|
[common_1.STORE_CONTENT]: 'Content of',
|
[common_1.STORE_LINKS]: 'Directory',
|
[common_1.STORE_STAT]: 'Stat info of',
|
}[task.store];
|
if (task.reason) {
|
log_1.log.debug(`${what} ${task.file} is added to queue. It was required from ${task.reason}`);
|
}
|
else {
|
log_1.log.debug(`${what} ${task.file} is added to queue.`);
|
}
|
}
|
appendSymlink(file, realFile) {
|
const a = findCommonJunctionPoint(file, realFile);
|
file = a.file;
|
realFile = a.realFile;
|
if (!this.symLinks[file]) {
|
const dn = path_1.default.dirname(file);
|
this.appendFileInFolder({
|
file: dn,
|
store: common_1.STORE_LINKS,
|
data: path_1.default.basename(file),
|
});
|
log_1.log.debug(`adding symlink ${file} => ${path_1.default.relative(file, realFile)}`);
|
this.symLinks[file] = realFile;
|
this.appendStat({
|
file: realFile,
|
store: common_1.STORE_STAT,
|
});
|
this.appendStat({
|
file: dn,
|
store: common_1.STORE_STAT,
|
});
|
this.appendStat({
|
file,
|
store: common_1.STORE_STAT,
|
});
|
}
|
}
|
appendStat(task) {
|
(0, assert_1.default)(task.store === common_1.STORE_STAT);
|
this.append(task);
|
}
|
appendFileInFolder(task) {
|
if (strictVerify) {
|
(0, assert_1.default)(task.store === common_1.STORE_LINKS);
|
(0, assert_1.default)(typeof task.file === 'string');
|
}
|
const realFile = (0, common_1.toNormalizedRealPath)(task.file);
|
if (realFile === task.file) {
|
this.append(task);
|
return;
|
}
|
this.append(Object.assign(Object.assign({}, task), { file: realFile }));
|
this.appendStat({
|
file: task.file,
|
store: common_1.STORE_STAT,
|
});
|
this.appendStat({
|
file: path_1.default.dirname(task.file),
|
store: common_1.STORE_STAT,
|
});
|
}
|
appendBlobOrContent(task) {
|
if (strictVerify) {
|
(0, assert_1.default)(task.file === (0, common_1.normalizePath)(task.file));
|
}
|
(0, assert_1.default)(task.store === common_1.STORE_BLOB || task.store === common_1.STORE_CONTENT);
|
(0, assert_1.default)(typeof task.file === 'string');
|
const realFile = (0, common_1.toNormalizedRealPath)(task.file);
|
if (realFile === task.file) {
|
this.append(task);
|
return;
|
}
|
this.append(Object.assign(Object.assign({}, task), { file: realFile }));
|
this.appendSymlink(task.file, realFile);
|
this.appendStat({
|
file: task.file,
|
store: common_1.STORE_STAT,
|
});
|
}
|
async appendFilesFromConfig(marker) {
|
const { config, configPath, base } = marker;
|
const pkgConfig = config === null || config === void 0 ? void 0 : config.pkg;
|
if (pkgConfig) {
|
let { scripts } = pkgConfig;
|
if (scripts) {
|
scripts = expandFiles(scripts, base);
|
for (const script of scripts) {
|
const stat = await fs_extra_1.default.stat(script);
|
if (stat.isFile()) {
|
if (!(0, common_1.isDotJS)(script) && !(0, common_1.isDotJSON)(script) && !(0, common_1.isDotNODE)(script)) {
|
log_1.log.warn("Non-javascript file is specified in 'scripts'.", [
|
'Pkg will probably fail to parse. Specify *.js in glob.',
|
script,
|
]);
|
}
|
this.appendBlobOrContent({
|
file: (0, common_1.normalizePath)(script),
|
marker,
|
store: common_1.STORE_BLOB,
|
reason: configPath,
|
});
|
}
|
}
|
}
|
let { assets } = pkgConfig;
|
if (assets) {
|
assets = expandFiles(assets, base);
|
for (const asset of assets) {
|
log_1.log.debug(' Adding asset : .... ', asset);
|
const stat = await fs_extra_1.default.stat(asset);
|
if (stat.isFile()) {
|
this.appendBlobOrContent({
|
file: (0, common_1.normalizePath)(asset),
|
marker,
|
store: common_1.STORE_CONTENT,
|
reason: configPath,
|
});
|
}
|
}
|
}
|
}
|
else if (config) {
|
let { files } = config;
|
if (files) {
|
files = expandFiles(files, base);
|
for (let file of files) {
|
file = (0, common_1.normalizePath)(file);
|
const stat = await fs_extra_1.default.stat(file);
|
if (stat.isFile()) {
|
// 1) remove sources of top-level(!) package 'files' i.e. ship as BLOB
|
// 2) non-source (non-js) files of top-level package are shipped as CONTENT
|
// 3) parsing some js 'files' of non-top-level packages fails, hence all CONTENT
|
if (marker.toplevel) {
|
this.appendBlobOrContent({
|
file,
|
marker,
|
store: (0, common_1.isDotJS)(file) ? common_1.STORE_BLOB : common_1.STORE_CONTENT,
|
reason: configPath,
|
});
|
}
|
else {
|
this.appendBlobOrContent({
|
file,
|
marker,
|
store: common_1.STORE_CONTENT,
|
reason: configPath,
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
async stepActivate(marker, derivatives) {
|
if (!marker) {
|
(0, assert_1.default)(false);
|
}
|
if (marker.activated) {
|
return;
|
}
|
const { config, base } = marker;
|
if (!config) {
|
(0, assert_1.default)(false);
|
}
|
const { name } = config;
|
if (name) {
|
const d = this.dictionary[name];
|
if (d) {
|
if (typeof config.dependencies === 'object' &&
|
typeof d.dependencies === 'object') {
|
Object.assign(config.dependencies, d.dependencies);
|
delete d.dependencies;
|
}
|
Object.assign(config, d);
|
marker.hasDictionary = true;
|
}
|
}
|
const { dependencies } = config;
|
if (typeof dependencies === 'object') {
|
for (const dependency in dependencies) {
|
// it may be `undefined` - overridden
|
// in dictionary (see publicsuffixlist)
|
if (dependencies[dependency]) {
|
derivatives.push({
|
alias: dependency,
|
aliasType: common_1.ALIAS_AS_RESOLVABLE,
|
fromDependencies: true,
|
});
|
derivatives.push({
|
alias: `${dependency}/package.json`,
|
aliasType: common_1.ALIAS_AS_RESOLVABLE,
|
fromDependencies: true,
|
});
|
}
|
}
|
}
|
const pkgConfig = config.pkg;
|
if (pkgConfig) {
|
const { patches } = pkgConfig;
|
if (patches) {
|
for (const key in patches) {
|
if (patches[key]) {
|
const p = path_1.default.join(base, key);
|
this.patches[p] = patches[key];
|
}
|
}
|
}
|
const { deployFiles } = pkgConfig;
|
if (deployFiles) {
|
marker.hasDeployFiles = true;
|
for (const deployFile of deployFiles) {
|
const type = deployFile[2] || 'file';
|
log_1.log.warn(`Cannot include ${type} %1 into executable.`, [
|
`The ${type} must be distributed with executable as %2.`,
|
`%1: ${path_1.default.relative(process.cwd(), path_1.default.join(base, deployFile[0]))}`,
|
`%2: path-to-executable/${deployFile[1]}`,
|
]);
|
}
|
}
|
if (pkgConfig.log) {
|
pkgConfig.log(log_1.log, { packagePath: base });
|
}
|
}
|
await this.appendFilesFromConfig(marker);
|
marker.public = isPublic(config);
|
if (!marker.public && marker.toplevel) {
|
marker.public = this.params.publicToplevel;
|
}
|
if (!marker.public && !marker.toplevel && this.params.publicPackages) {
|
marker.public =
|
this.params.publicPackages[0] === '*' ||
|
(!!name && this.params.publicPackages.indexOf(name) !== -1);
|
}
|
marker.activated = true;
|
// assert no further work with config
|
delete marker.config;
|
}
|
hasPatch(record) {
|
const patch = this.patches[record.file];
|
if (!patch) {
|
return;
|
}
|
return true;
|
}
|
stepPatch(record) {
|
const patch = this.patches[record.file];
|
if (!patch) {
|
return;
|
}
|
let body = (record.body || '').toString('utf8');
|
for (let i = 0; i < patch.length; i += 2) {
|
if (typeof patch[i] === 'object') {
|
if (patch[i].do === 'erase') {
|
body = patch[i + 1];
|
}
|
else if (patch[i].do === 'prepend') {
|
body = patch[i + 1] + body;
|
}
|
else if (patch[i].do === 'append') {
|
body += patch[i + 1];
|
}
|
}
|
else if (typeof patch[i] === 'string') {
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
|
// function escapeRegExp
|
const esc = patch[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
const regexp = new RegExp(esc, 'g');
|
body = body.replace(regexp, patch[i + 1]);
|
}
|
}
|
record.body = body;
|
}
|
async stepDerivatives_ALIAS_AS_RELATIVE(record, marker, derivative) {
|
const file = (0, common_1.normalizePath)(path_1.default.join(path_1.default.dirname(record.file), derivative.alias));
|
let stat;
|
try {
|
stat = await fs_extra_1.default.stat(file);
|
}
|
catch (error) {
|
const { toplevel } = marker;
|
const exception = error;
|
const debug = !toplevel && exception.code === 'ENOENT';
|
const level = debug ? 'debug' : 'warn';
|
log_1.log[level](`Cannot stat, ${exception.code}`, [
|
file,
|
`The file was required from '${record.file}'`,
|
]);
|
}
|
if (stat && stat.isFile()) {
|
this.appendBlobOrContent({
|
file,
|
marker,
|
store: common_1.STORE_CONTENT,
|
reason: record.file,
|
});
|
}
|
}
|
async stepDerivatives_ALIAS_AS_RESOLVABLE(record, marker, derivative) {
|
var _a, _b;
|
const newPackages = [];
|
const catchReadFile = (file) => {
|
(0, assert_1.default)((0, common_1.isPackageJson)(file), `walker: ${file} must be package.json`);
|
newPackages.push({ packageJson: file });
|
};
|
const catchPackageFilter = (config, base) => {
|
const newPackage = newPackages[newPackages.length - 1];
|
newPackage.marker = { config, configPath: newPackage.packageJson, base };
|
};
|
let newFile = '';
|
let failure;
|
const basedir = path_1.default.dirname(record.file);
|
try {
|
newFile = await (0, follow_1.follow)(derivative.alias, {
|
basedir,
|
// default is extensions: ['.js'], but
|
// it is not enough because 'typos.json'
|
// is not taken in require('./typos')
|
// in 'normalize-package-data/lib/fixer.js'
|
extensions: ['.js', '.json', '.node'],
|
catchReadFile,
|
catchPackageFilter,
|
});
|
}
|
catch (error) {
|
failure = error;
|
}
|
if (failure) {
|
const { toplevel } = marker;
|
const mainNotFound = newPackages.length > 0 && !((_b = (_a = newPackages[0].marker) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.main);
|
const debug = !toplevel ||
|
derivative.mayExclude ||
|
(mainNotFound && derivative.fromDependencies);
|
const level = debug ? 'debug' : 'warn';
|
if (mainNotFound) {
|
const message = "Entry 'main' not found in %1";
|
log_1.log[level](message, [
|
`%1: ${newPackages[0].packageJson}`,
|
`%2: ${record.file}`,
|
]);
|
}
|
else {
|
log_1.log[level](`${chalk_1.default.yellow(failure.message)} in ${record.file}`);
|
}
|
return;
|
}
|
let newPackageForNewRecords;
|
for (const newPackage of newPackages) {
|
let newFile2;
|
try {
|
newFile2 = await (0, follow_1.follow)(derivative.alias, {
|
basedir: path_1.default.dirname(record.file),
|
extensions: ['.js', '.json', '.node'],
|
ignoreFile: newPackage.packageJson,
|
});
|
if (strictVerify) {
|
(0, assert_1.default)(newFile2 === (0, common_1.normalizePath)(newFile2));
|
}
|
}
|
catch (_) {
|
// not setting is enough
|
}
|
if (newFile2 !== newFile) {
|
newPackageForNewRecords = newPackage;
|
break;
|
}
|
}
|
if (newPackageForNewRecords) {
|
if (strictVerify) {
|
(0, assert_1.default)(newPackageForNewRecords.packageJson ===
|
(0, common_1.normalizePath)(newPackageForNewRecords.packageJson));
|
}
|
this.appendBlobOrContent({
|
file: newPackageForNewRecords.packageJson,
|
marker: newPackageForNewRecords.marker,
|
store: common_1.STORE_CONTENT,
|
reason: record.file,
|
});
|
}
|
this.appendBlobOrContent({
|
file: newFile,
|
marker: newPackageForNewRecords ? newPackageForNewRecords.marker : marker,
|
store: common_1.STORE_BLOB,
|
reason: record.file,
|
});
|
}
|
async stepDerivatives(record, marker, derivatives) {
|
for (const derivative of derivatives) {
|
// TODO: actually use the target node version
|
if ((0, is_core_module_1.default)(derivative.alias, '99.0.0'))
|
continue;
|
switch (derivative.aliasType) {
|
case common_1.ALIAS_AS_RELATIVE:
|
await this.stepDerivatives_ALIAS_AS_RELATIVE(record, marker, derivative);
|
break;
|
case common_1.ALIAS_AS_RESOLVABLE:
|
await this.stepDerivatives_ALIAS_AS_RESOLVABLE(record, marker, derivative);
|
break;
|
default:
|
(0, assert_1.default)(false, `walker: unknown aliasType ${derivative.aliasType}`);
|
}
|
}
|
}
|
async step_STORE_ANY(record, marker, store) {
|
if (strictVerify) {
|
(0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file));
|
}
|
if (record[store] !== undefined)
|
return;
|
record[store] = false; // default is discard
|
this.appendStat({
|
file: record.file,
|
store: common_1.STORE_STAT,
|
});
|
const derivatives1 = [];
|
await this.stepActivate(marker, derivatives1);
|
await this.stepDerivatives(record, marker, derivatives1);
|
if (store === common_1.STORE_BLOB) {
|
if (unlikelyJavascript(record.file) || (0, common_1.isDotNODE)(record.file)) {
|
this.appendBlobOrContent({
|
file: record.file,
|
marker,
|
store: common_1.STORE_CONTENT,
|
});
|
return; // discard
|
}
|
if (marker.public || marker.hasDictionary) {
|
this.appendBlobOrContent({
|
file: record.file,
|
marker,
|
store: common_1.STORE_CONTENT,
|
});
|
}
|
}
|
if (store === common_1.STORE_BLOB || this.hasPatch(record)) {
|
if (!record.body) {
|
await stepRead(record);
|
this.stepPatch(record);
|
if (store === common_1.STORE_BLOB) {
|
stepStrip(record);
|
}
|
}
|
if (store === common_1.STORE_BLOB) {
|
const derivatives2 = [];
|
stepDetect(record, marker, derivatives2);
|
await this.stepDerivatives(record, marker, derivatives2);
|
}
|
}
|
record[store] = true;
|
}
|
step_STORE_LINKS(record, data) {
|
if (strictVerify) {
|
(0, assert_1.default)(record.file === (0, common_1.toNormalizedRealPath)(record.file), ' expecting real file !!!');
|
}
|
if (record[common_1.STORE_LINKS]) {
|
record[common_1.STORE_LINKS].push(data);
|
return;
|
}
|
record[common_1.STORE_LINKS] = [data];
|
if (record[common_1.STORE_STAT]) {
|
return;
|
}
|
this.appendStat({
|
file: record.file,
|
store: common_1.STORE_STAT,
|
});
|
}
|
async step_STORE_STAT(record) {
|
if (record[common_1.STORE_STAT])
|
return;
|
const realPath = (0, common_1.toNormalizedRealPath)(record.file);
|
if (realPath !== record.file) {
|
this.appendStat({
|
file: realPath,
|
store: common_1.STORE_STAT,
|
});
|
}
|
try {
|
const valueStat = await fs_extra_1.default.stat(record.file);
|
const value = {
|
mode: valueStat.mode,
|
size: valueStat.isFile() ? valueStat.size : 0,
|
isFileValue: valueStat.isFile(),
|
isDirectoryValue: valueStat.isDirectory(),
|
isSocketValue: valueStat.isSocket(),
|
isSymbolicLinkValue: valueStat.isSymbolicLink(),
|
};
|
record[common_1.STORE_STAT] = value;
|
}
|
catch (error) {
|
const exception = error;
|
log_1.log.error(`Cannot stat, ${exception.code}`, record.file);
|
throw (0, log_1.wasReported)(exception.message);
|
}
|
if (path_1.default.dirname(record.file) !== record.file) {
|
// root directory
|
this.appendFileInFolder({
|
file: path_1.default.dirname(record.file),
|
store: common_1.STORE_LINKS,
|
data: path_1.default.basename(record.file),
|
});
|
}
|
}
|
async step(task) {
|
const { file, store, data } = task;
|
const record = this.records[file];
|
switch (store) {
|
case common_1.STORE_BLOB:
|
case common_1.STORE_CONTENT:
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
await this.step_STORE_ANY(record, task.marker, store);
|
break;
|
case common_1.STORE_LINKS:
|
this.step_STORE_LINKS(record, data);
|
break;
|
case common_1.STORE_STAT:
|
await this.step_STORE_STAT(record);
|
break;
|
default:
|
(0, assert_1.default)(false, `walker: unknown store ${store}`);
|
}
|
}
|
async readDictionary(marker) {
|
var _a, _b, _c;
|
if (((_a = this.params.noDictionary) === null || _a === void 0 ? void 0 : _a[0]) === '*') {
|
return;
|
}
|
const dd = path_1.default.join(__dirname, '../dictionary');
|
const files = await fs_extra_1.default.readdir(dd);
|
for (const file of files) {
|
if (/\.js$/.test(file)) {
|
const name = file.slice(0, -3);
|
if ((_b = this.params.noDictionary) === null || _b === void 0 ? void 0 : _b.includes(file)) {
|
continue;
|
}
|
// eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires
|
const config = require(path_1.default.join(dd, file));
|
this.dictionary[name] = config;
|
}
|
}
|
const pkgConfig = (_c = marker.config) === null || _c === void 0 ? void 0 : _c.pkg;
|
if (pkgConfig) {
|
const { dictionary } = pkgConfig;
|
if (dictionary) {
|
for (const name in dictionary) {
|
if (dictionary[name]) {
|
this.dictionary[name] = { pkg: dictionary[name] };
|
}
|
}
|
}
|
}
|
}
|
async start(marker, entrypoint, addition, params) {
|
this.params = params;
|
this.symLinks = {};
|
await this.readDictionary(marker);
|
entrypoint = (0, common_1.normalizePath)(entrypoint);
|
this.appendBlobOrContent({
|
file: entrypoint,
|
marker,
|
store: common_1.STORE_BLOB,
|
});
|
if (addition) {
|
addition = (0, common_1.normalizePath)(addition);
|
this.appendBlobOrContent({
|
file: addition,
|
marker,
|
store: common_1.STORE_CONTENT,
|
});
|
}
|
const { tasks } = this;
|
for (let i = 0; i < tasks.length; i += 1) {
|
// NO MULTIPLE WORKERS! THIS WILL LEAD TO NON-DETERMINISTIC
|
// ORDER. one-by-one fifo is the only way to iterate tasks
|
await this.step(tasks[i]);
|
}
|
return {
|
symLinks: this.symLinks,
|
records: this.records,
|
entrypoint: (0, common_1.normalizePath)(entrypoint),
|
};
|
}
|
}
|
async function walker(...args) {
|
const w = new Walker();
|
return w.start(...args);
|
}
|
exports.default = walker;
|
//# sourceMappingURL=walker.js.map
|
