vinext 1.0.0-beta.9 → 1.0.0

package/dist/config/server-external-packages.js

@@ -1,3 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import fs from "node:fs";
 //#region src/config/server-external-packages.ts
 const DEFAULT_SERVER_EXTERNAL_PACKAGES = [
 	"@alinea/generated",
@@ -80,12 +82,44 @@ const DEFAULT_SERVER_EXTERNAL_PACKAGES = [
 	"websocket",
 	"zeromq"
 ];
-function mergeServerExternalPackages(userPackages = [], transpilePackages = []) {
+/**
+* OpenTelemetry's instrumentation packages must keep their native package
+* boundaries. In particular, `import-in-the-middle` shares a hook registry
+* between its Node loader and the Hook class imported by OpenTelemetry.
+* Bundling the latter creates a second registry and silently disables ESM
+* instrumentation.
+*
+* Externalizing the project's direct OpenTelemetry dependencies also keeps
+* their transitive IITM/RITM imports resolving from the owning package under
+* strict pnpm, instead of leaving an unresolvable bare import in dist/server.
+*/
+function findOpenTelemetryPackages(root) {
+	const packageJsonPath = path.join(root, "package.json");
+	let packageJson;
+	try {
+		packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const packageNames = /* @__PURE__ */ new Set();
+	for (const field of [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	]) {
+		const dependencies = packageJson[field];
+		if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue;
+		for (const packageName of Object.keys(dependencies)) if (packageName.startsWith("@opentelemetry/")) packageNames.add(packageName);
+	}
+	return [...packageNames];
+}
+function mergeServerExternalPackages(userPackages = [], transpilePackages = [], additionalDefaults = []) {
 	const transpiled = new Set(transpilePackages);
 	const conflicts = userPackages.filter((name) => transpiled.has(name));
 	if (conflicts.length > 0) throw new Error(`The packages specified in the 'transpilePackages' conflict with the 'serverExternalPackages': ${conflicts.join(", ")}`);
-	const defaults = DEFAULT_SERVER_EXTERNAL_PACKAGES.filter((name) => !transpiled.has(name));
+	const defaults = [...DEFAULT_SERVER_EXTERNAL_PACKAGES, ...additionalDefaults].filter((name) => !transpiled.has(name));
 	return [.../* @__PURE__ */ new Set([...defaults, ...userPackages])];
 }
 //#endregion
-export { mergeServerExternalPackages };
+export { findOpenTelemetryPackages, mergeServerExternalPackages };

package/dist/config/tsconfig-paths.d.ts

@@ -12,10 +12,9 @@ type TsconfigPathResolution = {
  * Errors during parsing are swallowed — this is a best-effort helper that
  * must not break config loading.
  */
-declare function loadTsconfigResolutionForRoot(projectRoot: string): TsconfigPathResolution;
+export declare function loadTsconfigResolutionForRoot(projectRoot: string): TsconfigPathResolution;
 /**
  * Back-compat helper for call sites that only need `compilerOptions.paths`.
  */
-declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
-//#endregion
-export { loadTsconfigPathAliasesForRoot, loadTsconfigResolutionForRoot };
+export declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
+//#endregion

package/dist/deps/.pnpm/ignore@5.3.2/deps/ignore/index.js

@@ -0,0 +1,189 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ignore@5.3.2/node_modules/ignore/index.js
+var require_ignore = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function makeArray(subject) {
+		return Array.isArray(subject) ? subject : [subject];
+	}
+	const EMPTY = "";
+	const SPACE = " ";
+	const ESCAPE = "\\";
+	const REGEX_TEST_BLANK_LINE = /^\s+$/;
+	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+	const REGEX_SPLITALL_CRLF = /\r?\n/g;
+	const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+	const SLASH = "/";
+	let TMP_KEY_IGNORE = "node-ignore";
+	/* istanbul ignore else */
+	if (typeof Symbol !== "undefined") TMP_KEY_IGNORE = Symbol.for("node-ignore");
+	const KEY_IGNORE = TMP_KEY_IGNORE;
+	const define = (object, key, value) => Object.defineProperty(object, key, { value });
+	const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+	const RETURN_FALSE = () => false;
+	const sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+	const cleanRangeBackSlash = (slashes) => {
+		const { length } = slashes;
+		return slashes.slice(0, length - length % 2);
+	};
+	const REPLACERS = [
+		[/^\uFEFF/, () => EMPTY],
+		[/((?:\\\\)*?)(\\?\s+)$/, (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)],
+		[/(\\+?)\s/g, (_, m1) => {
+			const { length } = m1;
+			return m1.slice(0, length - length % 2) + SPACE;
+		}],
+		[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
+		[/(?!\\)\?/g, () => "[^/]"],
+		[/^\//, () => "^"],
+		[/\//g, () => "\\/"],
+		[/^\^*\\\*\\\*\\\//, () => "^(?:.*\\/)?"],
+		[/^(?=[^^])/, function startingReplacer() {
+			return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+		}],
+		[/\\\/\\\*\\\*(?=\\\/|$)/g, (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"],
+		[/(^|[^\\]+)(\\\*)+(?=.+)/g, (_, p1, p2) => {
+			return p1 + p2.replace(/\\\*/g, "[^\\/]*");
+		}],
+		[/\\\\\\(?=[$.|*+(){^])/g, () => ESCAPE],
+		[/\\\\/g, () => ESCAPE],
+		[/(\\)?\[([^\]/]*?)(\\*)($|\])/g, (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"],
+		[/(?:[^*])$/, (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`],
+		[/(\^|\\\/)?\\\*$/, (_, p1) => {
+			return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
+		}]
+	];
+	const regexCache = Object.create(null);
+	const makeRegex = (pattern, ignoreCase) => {
+		let source = regexCache[pattern];
+		if (!source) {
+			source = REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+			regexCache[pattern] = source;
+		}
+		return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+	};
+	const isString = (subject) => typeof subject === "string";
+	const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+	const splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+	var IgnoreRule = class {
+		constructor(origin, pattern, negative, regex) {
+			this.origin = origin;
+			this.pattern = pattern;
+			this.negative = negative;
+			this.regex = regex;
+		}
+	};
+	const createRule = (pattern, ignoreCase) => {
+		const origin = pattern;
+		let negative = false;
+		if (pattern.indexOf("!") === 0) {
+			negative = true;
+			pattern = pattern.substr(1);
+		}
+		pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+		const regex = makeRegex(pattern, ignoreCase);
+		return new IgnoreRule(origin, pattern, negative, regex);
+	};
+	const throwError = (message, Ctor) => {
+		throw new Ctor(message);
+	};
+	const checkPath = (path, originalPath, doThrow) => {
+		if (!isString(path)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+		if (!path) return doThrow(`path must not be empty`, TypeError);
+		if (checkPath.isNotRelative(path)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
+		return true;
+	};
+	const isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+	checkPath.isNotRelative = isNotRelative;
+	checkPath.convert = (p) => p;
+	var Ignore = class {
+		constructor({ ignorecase = true, ignoreCase = ignorecase, allowRelativePaths = false } = {}) {
+			define(this, KEY_IGNORE, true);
+			this._rules = [];
+			this._ignoreCase = ignoreCase;
+			this._allowRelativePaths = allowRelativePaths;
+			this._initCache();
+		}
+		_initCache() {
+			this._ignoreCache = Object.create(null);
+			this._testCache = Object.create(null);
+		}
+		_addPattern(pattern) {
+			if (pattern && pattern[KEY_IGNORE]) {
+				this._rules = this._rules.concat(pattern._rules);
+				this._added = true;
+				return;
+			}
+			if (checkPattern(pattern)) {
+				const rule = createRule(pattern, this._ignoreCase);
+				this._added = true;
+				this._rules.push(rule);
+			}
+		}
+		add(pattern) {
+			this._added = false;
+			makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this);
+			if (this._added) this._initCache();
+			return this;
+		}
+		addPattern(pattern) {
+			return this.add(pattern);
+		}
+		_testOne(path, checkUnignored) {
+			let ignored = false;
+			let unignored = false;
+			this._rules.forEach((rule) => {
+				const { negative } = rule;
+				if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) return;
+				if (rule.regex.test(path)) {
+					ignored = !negative;
+					unignored = negative;
+				}
+			});
+			return {
+				ignored,
+				unignored
+			};
+		}
+		_test(originalPath, cache, checkUnignored, slices) {
+			const path = originalPath && checkPath.convert(originalPath);
+			checkPath(path, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+			return this._t(path, cache, checkUnignored, slices);
+		}
+		_t(path, cache, checkUnignored, slices) {
+			if (path in cache) return cache[path];
+			if (!slices) slices = path.split(SLASH);
+			slices.pop();
+			if (!slices.length) return cache[path] = this._testOne(path, checkUnignored);
+			const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+			return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+		}
+		ignores(path) {
+			return this._test(path, this._ignoreCache, false).ignored;
+		}
+		createFilter() {
+			return (path) => !this.ignores(path);
+		}
+		filter(paths) {
+			return makeArray(paths).filter(this.createFilter());
+		}
+		test(path) {
+			return this._test(path, this._testCache, true);
+		}
+	};
+	const factory = (options) => new Ignore(options);
+	const isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+	factory.isPathValid = isPathValid;
+	factory.default = factory;
+	module.exports = factory;
+	/* istanbul ignore if */
+	if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
+		const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+		checkPath.convert = makePosix;
+		const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+		checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+	}
+}));
+//#endregion
+export default require_ignore();
+export { require_ignore };