pncat/dist/merge-D6X7PPVO.mjs

A unified cli tool that enhances package managers catalogs feature.

import { a as __toESM, t as __commonJSMin } from "./chunk-D1OLi6Wq.mjs";
import { DEFAULT_CATALOG_RULES } from "./rules.mjs";
import process from "node:process";
import { resolve } from "pathe";

//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
function toArray(array) {
	array = array ?? [];
	return Array.isArray(array) ? array : [array];
}

//#endregion
//#region node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js
var require_cjs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var isMergeableObject = function isMergeableObject(value) {
		return isNonNullObject(value) && !isSpecial(value);
	};
	function isNonNullObject(value) {
		return !!value && typeof value === "object";
	}
	function isSpecial(value) {
		var stringValue = Object.prototype.toString.call(value);
		return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
	}
	var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.element") : 60103;
	function isReactElement(value) {
		return value.$$typeof === REACT_ELEMENT_TYPE;
	}
	function emptyTarget(val) {
		return Array.isArray(val) ? [] : {};
	}
	function cloneUnlessOtherwiseSpecified(value, options) {
		return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
	}
	function defaultArrayMerge(target, source, options) {
		return target.concat(source).map(function(element) {
			return cloneUnlessOtherwiseSpecified(element, options);
		});
	}
	function getMergeFunction(key, options) {
		if (!options.customMerge) return deepmerge;
		var customMerge = options.customMerge(key);
		return typeof customMerge === "function" ? customMerge : deepmerge;
	}
	function getEnumerableOwnPropertySymbols(target) {
		return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
			return Object.propertyIsEnumerable.call(target, symbol);
		}) : [];
	}
	function getKeys(target) {
		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
	}
	function propertyIsOnObject(object, property) {
		try {
			return property in object;
		} catch (_) {
			return false;
		}
	}
	function propertyIsUnsafe(target, key) {
		return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
	}
	function mergeObject(target, source, options) {
		var destination = {};
		if (options.isMergeableObject(target)) getKeys(target).forEach(function(key) {
			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
		});
		getKeys(source).forEach(function(key) {
			if (propertyIsUnsafe(target, key)) return;
			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
			else destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
		});
		return destination;
	}
	function deepmerge(target, source, options) {
		options = options || {};
		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
		var sourceIsArray = Array.isArray(source);
		if (!(sourceIsArray === Array.isArray(target))) return cloneUnlessOtherwiseSpecified(source, options);
		else if (sourceIsArray) return options.arrayMerge(target, source, options);
		else return mergeObject(target, source, options);
	}
	deepmerge.all = function deepmergeAll(array, options) {
		if (!Array.isArray(array)) throw new Error("first argument should be an array");
		return array.reduce(function(prev, next) {
			return deepmerge(prev, next, options);
		}, {});
	};
	var deepmerge_1 = deepmerge;
	module.exports = deepmerge_1;
}));

//#endregion
//#region src/utils/helper.ts
function isObject(value) {
	return !!value && typeof value === "object" && !Array.isArray(value);
}
function cloneDeep(data) {
	return structuredClone(data);
}
function getValueByPath(input, path) {
	return path.split(".").reduce((current, key) => {
		if (!isObject(current)) return void 0;
		return current[key];
	}, input);
}
function getCwd(options) {
	return resolve(options?.cwd || process.cwd());
}
function getDepSource(isDev = false, isOptional = false, isPeer = false) {
	return isDev ? "devDependencies" : isOptional ? "optionalDependencies" : isPeer ? "peerDependencies" : "dependencies";
}
function isDepFieldEnabled(options, depType) {
	return !!options.depFields?.[depType];
}
function isPnpmOverridesPackageName(pkgName) {
	return pkgName === "pnpm-workspace:overrides";
}
function hasEslint(packages) {
	for (const pkg of packages) {
		if (pkg.type !== "package.json") continue;
		if (pkg.deps.some((dep) => dep.name === "eslint")) return true;
	}
	return false;
}
function hasVSCodeEngine(packages) {
	for (const pkg of packages) {
		if (pkg.type !== "package.json") continue;
		if (pkg.raw.engines?.vscode) return true;
	}
	return false;
}

//#endregion
//#region src/utils/merge.ts
var import_cjs = /* @__PURE__ */ __toESM(require_cjs(), 1);
function mergeCatalogRules(...args) {
	const hasOptions = isObject(args[0]);
	const options = hasOptions ? args[0] : { mergeDefaults: true };
	const rules = hasOptions ? args.slice(1) : args;
	const { mergeDefaults = true, arrayMerge = mergeByName } = options;
	const sources = mergeDefaults ? [cloneDeep(DEFAULT_CATALOG_RULES), ...rules] : [...rules];
	return sources.length === 0 ? [] : sortCatalogRules(import_cjs.default.all(sources, { arrayMerge }));
}
function mergeByName(target, source) {
	const result = target.map((rule) => cloneDeep(rule));
	for (const sourceRuleRaw of source) {
		const sourceRule = cloneDeep(sourceRuleRaw);
		const existing = result.find((entry) => entry.name === sourceRule.name);
		if (!existing) {
			result.push(sourceRule);
			continue;
		}
		const merged = (0, import_cjs.default)({
			...existing,
			match: toArray(existing.match)
		}, {
			...sourceRule,
			match: toArray(sourceRule.match)
		});
		Object.assign(existing, merged);
	}
	return result;
}
function sortCatalogRules(rules) {
	return rules.sort((a, b) => (a.priority ?? Number.POSITIVE_INFINITY) - (b.priority ?? Number.POSITIVE_INFINITY));
}

//#endregion
export { getValueByPath as a, isDepFieldEnabled as c, require_cjs as d, toArray as f, getDepSource as i, isObject as l, cloneDeep as n, hasEslint as o, getCwd as r, hasVSCodeEngine as s, mergeCatalogRules as t, isPnpmOverridesPackageName as u };