mirror of
https://github.com/dawidd6/action-send-mail.git
synced 2024-11-15 00:01:07 +07:00
235 lines
11 KiB
JavaScript
235 lines
11 KiB
JavaScript
|
"use strict";
|
||
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
|
|
if (k2 === undefined) k2 = k;
|
||
|
|
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
|
|
}) : (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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
|
|
__setModuleDefault(result, mod);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
||
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
|
|
});
|
||
|
|
};
|
||
|
|
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
||
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
|
|
var m = o[Symbol.asyncIterator], i;
|
||
|
|
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||
|
|
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||
|
|
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||
|
|
};
|
||
|
|
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
|
||
|
|
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
|
||
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||
|
|
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||
|
|
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
||
|
|
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||
|
|
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||
|
|
function fulfill(value) { resume("next", value); }
|
||
|
|
function reject(value) { resume("throw", value); }
|
||
|
|
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||
|
|
};
|
||
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||
|
|
exports.DefaultGlobber = void 0;
|
||
|
|
const core = __importStar(require("@actions/core"));
|
||
|
|
const fs = __importStar(require("fs"));
|
||
|
|
const globOptionsHelper = __importStar(require("./internal-glob-options-helper"));
|
||
|
|
const path = __importStar(require("path"));
|
||
|
|
const patternHelper = __importStar(require("./internal-pattern-helper"));
|
||
|
|
const internal_match_kind_1 = require("./internal-match-kind");
|
||
|
|
const internal_pattern_1 = require("./internal-pattern");
|
||
|
|
const internal_search_state_1 = require("./internal-search-state");
|
||
|
|
const IS_WINDOWS = process.platform === 'win32';
|
||
|
|
class DefaultGlobber {
|
||
|
|
constructor(options) {
|
||
|
|
this.patterns = [];
|
||
|
|
this.searchPaths = [];
|
||
|
|
this.options = globOptionsHelper.getOptions(options);
|
||
|
|
}
|
||
|
|
getSearchPaths() {
|
||
|
|
// Return a copy
|
||
|
|
return this.searchPaths.slice();
|
||
|
|
}
|
||
|
|
glob() {
|
||
|
|
var e_1, _a;
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
const result = [];
|
||
|
|
try {
|
||
|
|
for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) {
|
||
|
|
const itemPath = _c.value;
|
||
|
|
result.push(itemPath);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
|
||
|
|
}
|
||
|
|
finally { if (e_1) throw e_1.error; }
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
globGenerator() {
|
||
|
|
return __asyncGenerator(this, arguments, function* globGenerator_1() {
|
||
|
|
// Fill in defaults options
|
||
|
|
const options = globOptionsHelper.getOptions(this.options);
|
||
|
|
// Implicit descendants?
|
||
|
|
const patterns = [];
|
||
|
|
for (const pattern of this.patterns) {
|
||
|
|
patterns.push(pattern);
|
||
|
|
if (options.implicitDescendants &&
|
||
|
|
(pattern.trailingSeparator ||
|
||
|
|
pattern.segments[pattern.segments.length - 1] !== '**')) {
|
||
|
|
patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**')));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Push the search paths
|
||
|
|
const stack = [];
|
||
|
|
for (const searchPath of patternHelper.getSearchPaths(patterns)) {
|
||
|
|
core.debug(`Search path '${searchPath}'`);
|
||
|
|
// Exists?
|
||
|
|
try {
|
||
|
|
// Intentionally using lstat. Detection for broken symlink
|
||
|
|
// will be performed later (if following symlinks).
|
||
|
|
yield __await(fs.promises.lstat(searchPath));
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
if (err.code === 'ENOENT') {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
stack.unshift(new internal_search_state_1.SearchState(searchPath, 1));
|
||
|
|
}
|
||
|
|
// Search
|
||
|
|
const traversalChain = []; // used to detect cycles
|
||
|
|
while (stack.length) {
|
||
|
|
// Pop
|
||
|
|
const item = stack.pop();
|
||
|
|
// Match?
|
||
|
|
const match = patternHelper.match(patterns, item.path);
|
||
|
|
const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
|
||
|
|
if (!match && !partialMatch) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// Stat
|
||
|
|
const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain)
|
||
|
|
// Broken symlink, or symlink cycle detected, or no longer exists
|
||
|
|
);
|
||
|
|
// Broken symlink, or symlink cycle detected, or no longer exists
|
||
|
|
if (!stats) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// Directory
|
||
|
|
if (stats.isDirectory()) {
|
||
|
|
// Matched
|
||
|
|
if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) {
|
||
|
|
yield yield __await(item.path);
|
||
|
|
}
|
||
|
|
// Descend?
|
||
|
|
else if (!partialMatch) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// Push the child items in reverse
|
||
|
|
const childLevel = item.level + 1;
|
||
|
|
const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel));
|
||
|
|
stack.push(...childItems.reverse());
|
||
|
|
}
|
||
|
|
// File
|
||
|
|
else if (match & internal_match_kind_1.MatchKind.File) {
|
||
|
|
yield yield __await(item.path);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Constructs a DefaultGlobber
|
||
|
|
*/
|
||
|
|
static create(patterns, options) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
const result = new DefaultGlobber(options);
|
||
|
|
if (IS_WINDOWS) {
|
||
|
|
patterns = patterns.replace(/\r\n/g, '\n');
|
||
|
|
patterns = patterns.replace(/\r/g, '\n');
|
||
|
|
}
|
||
|
|
const lines = patterns.split('\n').map(x => x.trim());
|
||
|
|
for (const line of lines) {
|
||
|
|
// Empty or comment
|
||
|
|
if (!line || line.startsWith('#')) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
// Pattern
|
||
|
|
else {
|
||
|
|
result.patterns.push(new internal_pattern_1.Pattern(line));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns));
|
||
|
|
return result;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
static stat(item, options, traversalChain) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
// Note:
|
||
|
|
// `stat` returns info about the target of a symlink (or symlink chain)
|
||
|
|
// `lstat` returns info about a symlink itself
|
||
|
|
let stats;
|
||
|
|
if (options.followSymbolicLinks) {
|
||
|
|
try {
|
||
|
|
// Use `stat` (following symlinks)
|
||
|
|
stats = yield fs.promises.stat(item.path);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
if (err.code === 'ENOENT') {
|
||
|
|
if (options.omitBrokenSymbolicLinks) {
|
||
|
|
core.debug(`Broken symlink '${item.path}'`);
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
|
||
|
|
}
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Use `lstat` (not following symlinks)
|
||
|
|
stats = yield fs.promises.lstat(item.path);
|
||
|
|
}
|
||
|
|
// Note, isDirectory() returns false for the lstat of a symlink
|
||
|
|
if (stats.isDirectory() && options.followSymbolicLinks) {
|
||
|
|
// Get the realpath
|
||
|
|
const realPath = yield fs.promises.realpath(item.path);
|
||
|
|
// Fixup the traversal chain to match the item level
|
||
|
|
while (traversalChain.length >= item.level) {
|
||
|
|
traversalChain.pop();
|
||
|
|
}
|
||
|
|
// Test for a cycle
|
||
|
|
if (traversalChain.some((x) => x === realPath)) {
|
||
|
|
core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
// Update the traversal chain
|
||
|
|
traversalChain.push(realPath);
|
||
|
|
}
|
||
|
|
return stats;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
exports.DefaultGlobber = DefaultGlobber;
|
||
|
|
//# sourceMappingURL=internal-globber.js.map
|