@codefast/cli 0.3.13-canary.3 → 0.3.13-canary.4

package/dist/lib/mirror/application/services/sync-workspace-package.service.mjs

@@ -0,0 +1,351 @@
+import { CliFsToken, CliLoggerToken, CliPathToken } from "../../../core/operational/contracts/tokens.mjs";
+import { messageFromCaughtUnknown } from "../../../core/application/utils/caught-unknown-message.util.mjs";
+import { FileSystemServicePortToken, MirrorSyncReporterPortToken, PackageRepositoryPortToken } from "../../contracts/tokens.mjs";
+import { DIST_DIR, PACKAGE_JSON } from "../../domain/constants.domain.mjs";
+import { createPathTransform, generateExports } from "../use-cases/generate-mirror-exports.use-case.mjs";
+import { injectable } from "@codefast/di";
+//#region src/lib/mirror/application/services/sync-workspace-package.service.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return;
+	return configMap[pkgMeta.packageName];
+}
+function isPackageSkipped(skipPackagesArray, pkgMeta) {
+	if (!skipPackagesArray) return false;
+	return skipPackagesArray.includes(pkgMeta.packageName);
+}
+_dec = injectable([
+	CliFsToken,
+	CliPathToken,
+	PackageRepositoryPortToken,
+	FileSystemServicePortToken,
+	CliLoggerToken,
+	MirrorSyncReporterPortToken
+]);
+let _SyncWorkspacePackageServiceImpl;
+(class {
+	fs;
+	pathService;
+	packageRepository;
+	fileSystemService;
+	logger;
+	mirrorReporter;
+	static {
+		({c: [_SyncWorkspacePackageServiceImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fs, pathService, packageRepository, fileSystemService, logger, mirrorReporter) {
+		this.fs = fs;
+		this.pathService = pathService;
+		this.packageRepository = packageRepository;
+		this.fileSystemService = fileSystemService;
+		this.logger = logger;
+		this.mirrorReporter = mirrorReporter;
+	}
+	async syncExportsForWorkspacePackage(rootDir, packagePathStr, index, total, config, verbose, stats, suppressMirrorLogs = false) {
+		const packageDir = this.pathService.resolve(rootDir, packagePathStr);
+		const distDir = this.pathService.join(packageDir, DIST_DIR);
+		const packageJsonPath = this.pathService.join(packageDir, PACKAGE_JSON);
+		const folderBasename = this.pathService.basename(packageDir);
+		const pkgStats = {
+			name: folderBasename,
+			path: packageDir,
+			jsModules: 0,
+			cssExports: 0,
+			customExports: 0,
+			totalExports: 0,
+			hasTransform: false,
+			cssConfigStatus: "",
+			skipped: false,
+			skipReason: "",
+			error: null
+		};
+		if (!this.fs.existsSync(packageJsonPath)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "package.json not found";
+			stats.packagesSkipped++;
+			if (!suppressMirrorLogs) this.mirrorReporter.logSkippedWorkspacePackage(this.logger, index, total, folderBasename, pkgStats.skipReason);
+			return pkgStats;
+		}
+		let packageJsonParseError;
+		try {
+			const pkgContent = await this.fs.readFile(packageJsonPath, "utf8");
+			const raw = JSON.parse(pkgContent);
+			const parsedPackageJson = this.packageRepository.parsePackageJsonShape(raw);
+			pkgStats.name = this.packageRepository.resolvePackageDisplayName(parsedPackageJson, folderBasename);
+		} catch (caughtError) {
+			pkgStats.name = folderBasename;
+			packageJsonParseError = caughtError;
+		}
+		const pkgMeta = { packageName: pkgStats.name };
+		if (isPackageSkipped(config.skipPackages, pkgMeta)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "configured to skip";
+			stats.packagesSkipped++;
+			if (!suppressMirrorLogs) this.mirrorReporter.logSkippedWorkspacePackage(this.logger, index, total, pkgStats.name, pkgStats.skipReason);
+			return pkgStats;
+		}
+		if (packageJsonParseError !== void 0) {
+			if (!this.fs.existsSync(distDir)) {
+				pkgStats.skipped = true;
+				pkgStats.skipReason = "dist/ not found";
+				stats.packagesSkipped++;
+				if (!suppressMirrorLogs) this.mirrorReporter.logSkippedWorkspacePackage(this.logger, index, total, pkgStats.name, pkgStats.skipReason);
+				return pkgStats;
+			}
+			pkgStats.error = messageFromCaughtUnknown(packageJsonParseError);
+			stats.packagesErrored++;
+			if (!suppressMirrorLogs) this.mirrorReporter.logPackageError(this.logger, index, total, pkgStats.name, packageJsonParseError, verbose);
+			return pkgStats;
+		}
+		if (!this.fs.existsSync(distDir)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "dist/ not found";
+			stats.packagesSkipped++;
+			if (!suppressMirrorLogs) this.mirrorReporter.logSkippedWorkspacePackage(this.logger, index, total, pkgStats.name, pkgStats.skipReason);
+			return pkgStats;
+		}
+		try {
+			const pathTransform = createPathTransform(config, pkgMeta);
+			pkgStats.hasTransform = !!pathTransform;
+			const cssConfig = resolvePackageScopedConfig(config.cssExports, pkgMeta);
+			if (cssConfig === false) pkgStats.cssConfigStatus = "disabled";
+			else if (cssConfig !== void 0) pkgStats.cssConfigStatus = "configured";
+			const customExports = resolvePackageScopedConfig(config.customExports, pkgMeta) || {};
+			const generatedExports = await generateExports(this.fs, this.pathService, this.fileSystemService, distDir, pathTransform, cssConfig, customExports);
+			const { prunedKeys } = await this.packageRepository.writePackageJsonExportsAtomic(this.fs, packageJsonPath, {
+				generatedExports: generatedExports.exports,
+				managedExportSpecifiers: Object.keys(generatedExports.exports),
+				originalPathBySpecifier: generatedExports.originalPathBySpecifier
+			});
+			for (const exportSpecifier of prunedKeys) if (!suppressMirrorLogs) this.mirrorReporter.logPrunedStaleExport(this.logger, exportSpecifier);
+			pkgStats.jsModules = generatedExports.jsCount;
+			pkgStats.cssExports = generatedExports.cssCount;
+			pkgStats.customExports = Object.keys(customExports).length;
+			pkgStats.totalExports = Object.keys(generatedExports.exports).length;
+			stats.packagesProcessed++;
+			stats.totalExports += pkgStats.totalExports;
+			stats.totalJsModules += pkgStats.jsModules;
+			stats.totalCssExports += pkgStats.cssExports;
+			if (!suppressMirrorLogs) this.mirrorReporter.logPackageSuccess(this.logger, index, total, pkgStats, generatedExports, verbose);
+		} catch (caughtError) {
+			pkgStats.error = messageFromCaughtUnknown(caughtError);
+			stats.packagesErrored++;
+			if (!suppressMirrorLogs) this.mirrorReporter.logPackageError(this.logger, index, total, pkgStats.name, caughtError, verbose);
+		}
+		return pkgStats;
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _SyncWorkspacePackageServiceImpl as SyncWorkspacePackageServiceImpl };

package/dist/lib/mirror/application/use-cases/generate-mirror-exports.use-case.mjs

@@ -0,0 +1,219 @@
+import { PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS } from "../../domain/constants.domain.mjs";
+//#region src/lib/mirror/application/use-cases/generate-mirror-exports.use-case.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return;
+	return configMap[pkgMeta.packageName];
+}
+function groupFilesByModule(files, pathService) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		let ext;
+		let modulePath;
+		const dtsExt = Array.from(VALID_DTS_EXTENSIONS).find((candidate) => file.endsWith(candidate));
+		if (dtsExt) {
+			ext = dtsExt;
+			modulePath = file.slice(0, -dtsExt.length);
+		} else {
+			ext = pathService.extname(file);
+			if (!VALID_JS_EXTENSIONS.has(ext)) continue;
+			modulePath = file.slice(0, -ext.length);
+		}
+		if (!pathService.basename(modulePath)) continue;
+		let distModule = modules.get(modulePath);
+		if (!distModule) {
+			distModule = {
+				path: modulePath,
+				files: {
+					js: null,
+					mjs: null,
+					cjs: null,
+					dts: null
+				}
+			};
+			modules.set(modulePath, distModule);
+		}
+		if (ext === ".js") distModule.files.js = file;
+		else if (ext === ".mjs") distModule.files.mjs = file;
+		else if (ext === ".cjs") distModule.files.cjs = file;
+		else if (VALID_DTS_EXTENSIONS.has(ext)) distModule.files.dts = file;
+	}
+	return modules;
+}
+function toExportPath(distPath) {
+	if (distPath === "index") return ".";
+	if (distPath.endsWith("/index")) return `./${distPath.slice(0, -6)}`;
+	return `./${distPath}`;
+}
+const GROUP_ORDER = {
+	components: 100,
+	hooks: 200,
+	primitives: 300,
+	core: 400,
+	loaders: 500,
+	utils: 600,
+	adapters: 700,
+	script: 750,
+	css: 900
+};
+function getExportGroup(exportPath, pathTransform) {
+	if (exportPath === ".") return [
+		".",
+		"",
+		0,
+		0
+	];
+	const cleanPath = exportPath.startsWith("./") ? exportPath.slice(2) : exportPath;
+	if (cleanPath.endsWith("/*")) {
+		const dirName = cleanPath.slice(0, -2);
+		return [
+			dirName,
+			"",
+			dirName === "css" ? 900 : 100,
+			0
+		];
+	}
+	const parts = cleanPath.split("/");
+	if (parts.length === 1) {
+		const name = parts[0];
+		if (name === void 0) throw new Error("invariant: export path segment missing");
+		if (name in GROUP_ORDER) return [
+			name,
+			"",
+			GROUP_ORDER[name] ?? 0,
+			0
+		];
+		if (pathTransform) return [
+			"components",
+			name,
+			100,
+			1
+		];
+		return [
+			"",
+			name,
+			800,
+			1
+		];
+	}
+	const group = parts[0] ?? "";
+	return [
+		group,
+		parts.slice(1).join("/"),
+		GROUP_ORDER[group] ?? 700,
+		1
+	];
+}
+function createPathTransform(config, pkgMeta) {
+	const pathConfig = resolvePackageScopedConfig(config?.pathTransformations, pkgMeta);
+	if (!pathConfig) return null;
+	const { removePrefix } = pathConfig;
+	if (!removePrefix) return null;
+	return (exportPath) => {
+		if (!exportPath.startsWith(removePrefix)) return exportPath;
+		const result = exportPath.slice(removePrefix.length);
+		if (result && result !== "." && !result.startsWith("./")) return `./${result}`;
+		return result;
+	};
+}
+function getSortTuple(exportPath, pathTransform) {
+	const [group, subpath, order, isIndex] = getExportGroup(exportPath, pathTransform);
+	return [
+		order,
+		group,
+		isIndex,
+		subpath
+	];
+}
+function compareTuples(left, right) {
+	if (left[0] !== right[0]) return left[0] - right[0];
+	if (left[1] !== right[1]) return left[1] < right[1] ? -1 : 1;
+	if (left[2] !== right[2]) return left[2] - right[2];
+	if (left[3] !== right[3]) return left[3] < right[3] ? -1 : 1;
+	return 0;
+}
+async function generateCssExports(fs, pathService, fileSystemService, distDir, cssConfig) {
+	if (cssConfig === false) return {};
+	if (cssConfig === true) cssConfig = { enabled: true };
+	if (!cssConfig || cssConfig.enabled === false) return {};
+	const cssFiles = (await fileSystemService.listRelativeFilesRecursively(fs, distDir)).filter((relativeDistPath) => relativeDistPath.endsWith(".css"));
+	if (!cssFiles.length) return {};
+	const cssExports = { ...cssConfig.customExports };
+	const cssByDir = /* @__PURE__ */ new Map();
+	const rootCss = [];
+	for (const file of cssFiles) {
+		const dirName = pathService.dirname(file).split(pathService.separator).join("/");
+		if (dirName === ".") rootCss.push(file);
+		else {
+			const arr = cssByDir.get(dirName) || [];
+			arr.push(file);
+			cssByDir.set(dirName, arr);
+		}
+	}
+	for (const file of rootCss) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	for (const [dirName, dirFiles] of cssByDir.entries()) if (await fileSystemService.isDirectoryCssOnly(fs, distDir, dirName) && !cssConfig.forceExportFiles) {
+		const wildcardExport = `./${dirName}/*`;
+		if (!(wildcardExport in cssExports)) cssExports[wildcardExport] = `./dist/${dirName}/*`;
+	} else for (const file of dirFiles) {
+		const exportPath = `./${file}`;
+		if (!(exportPath in cssExports)) cssExports[exportPath] = `./dist/${file}`;
+	}
+	return cssExports;
+}
+/**
+* Compute `package.json#exports` from a built `dist/` tree. No logging; no writes.
+*/ async function generateExports(fs, pathService, fileSystemService, distDir, pathTransform, cssConfig, customExports) {
+	const files = await fileSystemService.listRelativeFilesRecursively(fs, distDir);
+	if (!files.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		originalPathBySpecifier: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const modules = groupFilesByModule(files, pathService);
+	const validModules = Array.from(modules.values()).filter((moduleEntry) => (moduleEntry.files.js || moduleEntry.files.mjs) && moduleEntry.files.dts);
+	if (!validModules.length) return {
+		exports: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		originalPathBySpecifier: { [PACKAGE_JSON_EXPORT]: PACKAGE_JSON_EXPORT },
+		jsCount: 0,
+		cssCount: 0
+	};
+	const exportsObj = {};
+	const originalPathBySpecifier = {};
+	for (const distModuleEntry of validModules) {
+		const originalExportPath = toExportPath(distModuleEntry.path);
+		let exportPath = originalExportPath;
+		if (pathTransform) exportPath = pathTransform(exportPath);
+		const dtsFile = distModuleEntry.files.dts;
+		if (dtsFile === void 0) throw new Error(`mirror exports: missing .d.ts for ${distModuleEntry.path}`);
+		const entry = { types: `./dist/${dtsFile}` };
+		if (distModuleEntry.files.mjs) entry.import = `./dist/${distModuleEntry.files.mjs}`;
+		else if (distModuleEntry.files.js) entry.import = `./dist/${distModuleEntry.files.js}`;
+		if (distModuleEntry.files.cjs) entry.require = `./dist/${distModuleEntry.files.cjs}`;
+		exportsObj[exportPath] = entry;
+		originalPathBySpecifier[exportPath] = originalExportPath;
+	}
+	let sortedKeys = Object.keys(exportsObj).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const sortedExports = {};
+	for (const exportKey of sortedKeys) sortedExports[exportKey] = exportsObj[exportKey];
+	const cssExports = await generateCssExports(fs, pathService, fileSystemService, distDir, cssConfig ?? { enabled: true });
+	Object.assign(sortedExports, cssExports);
+	for (const [specifier, mappedPath] of Object.entries(customExports || {})) if (specifier !== "./package.json") sortedExports[specifier] = mappedPath;
+	for (const cssSpecifier of Object.keys(cssExports)) if (!(cssSpecifier in originalPathBySpecifier)) originalPathBySpecifier[cssSpecifier] = cssSpecifier;
+	for (const customSpecifier of Object.keys(customExports || {})) if (customSpecifier !== "./package.json" && !(customSpecifier in originalPathBySpecifier)) originalPathBySpecifier[customSpecifier] = customSpecifier;
+	sortedKeys = Object.keys(sortedExports).filter((exportKey) => exportKey !== PACKAGE_JSON_EXPORT).sort((pathA, pathB) => compareTuples(getSortTuple(pathA, pathTransform), getSortTuple(pathB, pathTransform)));
+	const finalExports = {};
+	for (const exportKey of sortedKeys) finalExports[exportKey] = sortedExports[exportKey];
+	finalExports[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	originalPathBySpecifier[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+	return {
+		exports: finalExports,
+		originalPathBySpecifier,
+		jsCount: Object.keys(exportsObj).length,
+		cssCount: Object.keys(cssExports).length
+	};
+}
+//#endregion
+export { createPathTransform, generateExports };