JiboSDK/node_modules/del/index.js

"use strict";

// Pulsar/Atom loads packages via CommonJS `require()`. Modern `del` is ESM-only
// and requires Node >= 18. jibo-dev (bundled in this SDK) only needs the basic
// `del(patterns)` promise API for cleaning build outputs.

var fs = require("fs");
var path = require("path");

function normalizePatterns(patterns) {
	if (!patterns) return [];
	patterns = Array.isArray(patterns) ? patterns : [patterns];

	// Support negation patterns by ignoring them (good enough for our usage).
	return patterns.filter(function (p) {
		return typeof p === "string" && p.length > 0 && p[0] !== "!";
	});
}

function isInside(childPath, parentPath) {
	var rel = path.relative(parentPath, childPath);
	return rel && rel !== ".." && rel.indexOf(".." + path.sep) !== 0 && !path.isAbsolute(rel);
}

function rmRecursiveSync(targetPath) {
	try {
		var stat = fs.lstatSync(targetPath);
		if (stat.isDirectory() && !stat.isSymbolicLink()) {
			var entries = fs.readdirSync(targetPath);
			for (var i = 0; i < entries.length; i++) {
				rmRecursiveSync(path.join(targetPath, entries[i]));
			}
			fs.rmdirSync(targetPath);
			return;
		}

		fs.unlinkSync(targetPath);
	} catch (err) {
		if (err && (err.code === "ENOENT" || err.code === "ENOTDIR")) return;
		throw err;
	}
}

function expandIfGlob(pattern) {
	// If glob isn't installed/available, just treat as a literal path.
	if (!/[\*\?\[\]\{\}]/.test(pattern)) return [pattern];

	try {
		var glob = require("glob");
		if (glob && typeof glob.sync === "function") {
			return glob.sync(pattern, { dot: true, nodir: false });
		}
	} catch (_) {}

	return [pattern];
}

function del(patterns, options) {
	options = options || {};
	var cwd = options.cwd ? path.resolve(String(options.cwd)) : process.cwd();
	var force = Boolean(options.force);
	var dryRun = Boolean(options.dryRun);

	patterns = normalizePatterns(patterns);

	var files = [];
	patterns.forEach(function (p) {
		expandIfGlob(p).forEach(function (m) {
			files.push(m);
		});
	});

	// Dedupe + stable sort (close enough to del's behavior).
	var seen = Object.create(null);
	files = files.filter(function (f) {
		if (!f || typeof f !== "string") return false;
		if (seen[f]) return false;
		seen[f] = true;
		return true;
	}).sort();

	return Promise.resolve().then(function () {
		var removed = [];
		for (var i = 0; i < files.length; i++) {
			var abs = path.resolve(cwd, files[i]);
			if (!force && !isInside(abs, cwd)) {
				// Skip unsafe paths rather than throwing; build clean should be best-effort.
				continue;
			}
			if (!dryRun) rmRecursiveSync(abs);
			removed.push(abs);
		}
		return removed;
	});
}

del.sync = function (patterns, options) {
	options = options || {};
	var cwd = options.cwd ? path.resolve(String(options.cwd)) : process.cwd();
	var force = Boolean(options.force);
	var dryRun = Boolean(options.dryRun);

	patterns = normalizePatterns(patterns);

	var files = [];
	patterns.forEach(function (p) {
		expandIfGlob(p).forEach(function (m) {
			files.push(m);
		});
	});

	var seen = Object.create(null);
	files = files.filter(function (f) {
		if (!f || typeof f !== "string") return false;
		if (seen[f]) return false;
		seen[f] = true;
		return true;
	}).sort();

	var removed = [];
	for (var i = 0; i < files.length; i++) {
		var abs = path.resolve(cwd, files[i]);
		if (!force && !isInside(abs, cwd)) continue;
		if (!dryRun) rmRecursiveSync(abs);
		removed.push(abs);
	}

	return removed;
};

module.exports = del;
module.exports.deleteAsync = del;
module.exports.deleteSync = del.sync;