@effected/workspaces 0.25.0 → 0.26.0

package/internal/sourceText.js

@@ -0,0 +1,333 @@
+//#region src/internal/sourceText.ts
+const IDENTIFIER = /[\p{ID_Continue}$\u200c\u200d]/u;
+const SPACE = /\s/;
+const FLAG = /[a-z]/i;
+/** Keywords after which a `/` opens a regex literal rather than a division. */
+const REGEX_AFTER = /* @__PURE__ */ new Set([
+	"return",
+	"typeof",
+	"instanceof",
+	"in",
+	"of",
+	"new",
+	"delete",
+	"void",
+	"throw",
+	"case",
+	"do",
+	"else",
+	"yield",
+	"await"
+]);
+/** Keywords whose parenthesized condition may be followed directly by a statement, so a `/` after its `)` opens a regex. */
+const CONTROL = /* @__PURE__ */ new Set([
+	"if",
+	"while",
+	"for",
+	"with"
+]);
+/** Objects a member access on which still reaches a global. */
+const GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
+	"globalThis",
+	"global",
+	"window",
+	"self"
+]);
+/** Whether `char` can continue an identifier. */
+const isIdentifierChar = (char) => char !== void 0 && IDENTIFIER.test(char);
+/** Lex `text` once into its comment-free view, its code-only view and its literals. */
+const lex = (text) => {
+	const kept = [];
+	const code = [];
+	const literals = [];
+	const substitutions = [];
+	const parens = [];
+	const controlCloses = /* @__PURE__ */ new Set();
+	const length = text.length;
+	let i = 0;
+	const blank = (char) => char === "\n" || char === "\r" ? char : " ";
+	/** Emit one input character: `keep` for the comment-free view, `live` for the code view. */
+	const emit = (char, keep, live) => {
+		kept.push(keep ? char : blank(char));
+		code.push(live ? char : blank(char));
+	};
+	/** The last non-space offset in the code view at or before `from`; `-1` when there is none. */
+	const lastCode = (from) => {
+		let j = from;
+		while (j >= 0 && SPACE.test(code[j] ?? "")) j--;
+		return j;
+	};
+	/** The identifier ending at code offset `end`, or `""`. */
+	const wordAt = (end) => {
+		let start = end;
+		while (start >= 0 && isIdentifierChar(code[start])) start--;
+		return code.slice(start + 1, end + 1).join("");
+	};
+	/** Whether the code at offset `j` ends an operand (a value a postfix operator or a `/` division can follow). */
+	const endsOperand = (j) => {
+		const char = code[j] ?? "";
+		return char === ")" || char === "]" || isIdentifierChar(char) && !REGEX_AFTER.has(wordAt(j));
+	};
+	/** Whether a `/` here opens a regex, judged by the last code token. */
+	const regexAllowed = () => {
+		const j = lastCode(code.length - 1);
+		if (j < 0) return true;
+		const last = code[j] ?? "";
+		if (isIdentifierChar(last)) return REGEX_AFTER.has(wordAt(j));
+		if (last === "!") return !endsOperand(j - 1);
+		if ((last === "+" || last === "-") && code[j - 1] === last) return !endsOperand(lastCode(j - 2));
+		if (last === ")") return controlCloses.has(j);
+		return !"]}\"'`".includes(last);
+	};
+	/** Whether the `(` about to be emitted opens an if/while/for/with condition. */
+	const opensCondition = () => {
+		const j = lastCode(code.length - 1);
+		if (j < 0 || !isIdentifierChar(code[j])) return false;
+		let word = wordAt(j);
+		let end = j - word.length;
+		if (word === "await") {
+			end = lastCode(end);
+			word = end < 0 ? "" : wordAt(end);
+			end -= word.length;
+		}
+		return CONTROL.has(word) && code[lastCode(end)] !== ".";
+	};
+	/** Consume a regex literal at `i` if one closes on this line; `false` leaves `i` untouched. */
+	const regex = () => {
+		let j = i + 1;
+		let inClass = false;
+		for (; j < length; j++) {
+			const char = text[j] ?? "";
+			if (char === "\n" || char === "\r") return false;
+			if (char === "\\") {
+				j++;
+				continue;
+			}
+			if (inClass) {
+				if (char === "]") inClass = false;
+			} else if (char === "[") inClass = true;
+			else if (char === "/") break;
+		}
+		if (j >= length) return false;
+		emit("/", true, true);
+		for (let k = i + 1; k < j; k++) emit(text[k] ?? "", true, false);
+		emit("/", true, true);
+		i = j + 1;
+		while (i < length && FLAG.test(text[i] ?? "")) {
+			emit(text[i] ?? "", true, true);
+			i++;
+		}
+		return true;
+	};
+	/** Consume a `"` or `'` string starting at `i`. An unterminated one stops at the line break. */
+	const string = (quote) => {
+		const start = i;
+		emit(quote, true, true);
+		i++;
+		while (i < length) {
+			const char = text[i] ?? "";
+			if (char === "\\") {
+				emit(char, true, false);
+				i++;
+				if (i < length) {
+					emit(text[i] ?? "", true, false);
+					i++;
+				}
+				continue;
+			}
+			if (char === quote) {
+				emit(char, true, true);
+				i++;
+				literals.push({
+					start,
+					value: text.slice(start + 1, i - 1)
+				});
+				return;
+			}
+			if (char === "\n") return;
+			emit(char, true, false);
+			i++;
+		}
+	};
+	/** Consume template text up to its closing backtick or the next `${`. */
+	const templateText = () => {
+		while (i < length) {
+			const char = text[i] ?? "";
+			if (char === "\\") {
+				emit(char, true, false);
+				i++;
+				if (i < length) {
+					emit(text[i] ?? "", true, false);
+					i++;
+				}
+				continue;
+			}
+			if (char === "`") {
+				emit(char, true, true);
+				i++;
+				return "end";
+			}
+			if (char === "$" && text[i + 1] === "{") {
+				emit("$", true, true);
+				emit("{", true, true);
+				i += 2;
+				return "substitution";
+			}
+			emit(char, true, false);
+			i++;
+		}
+		return "eof";
+	};
+	if (text.startsWith("#!")) while (i < length && text[i] !== "\n") {
+		emit(text[i] ?? "", false, false);
+		i++;
+	}
+	while (i < length) {
+		const char = text[i] ?? "";
+		const next = text[i + 1];
+		if (char === "/" && next === "/") while (i < length && text[i] !== "\n") {
+			emit(text[i] ?? "", false, false);
+			i++;
+		}
+		else if (char === "/" && next === "*") {
+			const close = text.indexOf("*/", i + 2);
+			const end = close === -1 ? length : close + 2;
+			while (i < end) {
+				emit(text[i] ?? "", false, false);
+				i++;
+			}
+		} else if (char === "\"" || char === "'") string(char);
+		else if (char === "`") {
+			const start = i;
+			emit(char, true, true);
+			i++;
+			const stop = templateText();
+			if (stop === "end") literals.push({
+				start,
+				value: text.slice(start + 1, i - 1)
+			});
+			else if (stop === "substitution") substitutions.push(0);
+		} else if (char === "/" && regexAllowed() && regex()) {} else if (char === "(") {
+			parens.push(opensCondition());
+			emit(char, true, true);
+			i++;
+		} else if (char === ")") {
+			if (parens.pop() === true) controlCloses.add(code.length);
+			emit(char, true, true);
+			i++;
+		} else if (char === "{") {
+			const depth = substitutions.at(-1);
+			if (depth !== void 0) substitutions[substitutions.length - 1] = depth + 1;
+			emit(char, true, true);
+			i++;
+		} else if (char === "}") {
+			const depth = substitutions.at(-1);
+			emit(char, true, true);
+			i++;
+			if (depth === 0) {
+				substitutions.pop();
+				if (templateText() === "substitution") substitutions.push(0);
+			} else if (depth !== void 0) substitutions[substitutions.length - 1] = depth - 1;
+		} else {
+			emit(char, true, true);
+			i++;
+		}
+	}
+	return {
+		withoutComments: kept.join(""),
+		code: code.join(""),
+		literals
+	};
+};
+/**
+* Whether the identifier ending just before `after` is an object-literal key or
+* a type member (`{ process: 1 }`, `interface I { process?: string }`): the
+* previous code character (at `before`) is `{`, `,` or `;` and the next one is
+* `:` or `?:`. A ternary branch (`ok ? process : x`) follows `?`, so it still counts.
+*/
+const isPropertyKey = (code, before, after) => {
+	if (before < 0 || !"{,;".includes(code[before] ?? "")) return false;
+	let k = after;
+	while (k < code.length && SPACE.test(code[k] ?? "")) k++;
+	if (code[k] === "?") {
+		k++;
+		while (k < code.length && SPACE.test(code[k] ?? "")) k++;
+	}
+	return code[k] === ":";
+};
+/**
+* Offsets where `name` is referenced in lexed `code` as a free identifier, a
+* member of a global object, or a spread operand. A member of any other object
+* (`child.process`), a longer identifier, a private field and an object-literal
+* key or type member are not.
+*/
+const references = (code, name) => {
+	const found = [];
+	for (let at = code.indexOf(name); at !== -1; at = code.indexOf(name, at + name.length)) {
+		const before = code[at - 1];
+		if (isIdentifierChar(before) || before === "#" || isIdentifierChar(code[at + name.length])) continue;
+		let j = at - 1;
+		while (j >= 0 && SPACE.test(code[j] ?? "")) j--;
+		if (code[j] !== ".") {
+			if (!isPropertyKey(code, j, at + name.length)) found.push(at);
+			continue;
+		}
+		if (code[j - 1] === "." && code[j - 2] === ".") {
+			found.push(at);
+			continue;
+		}
+		let end = code[j - 1] === "?" ? j - 2 : j - 1;
+		while (end >= 0 && SPACE.test(code[end] ?? "")) end--;
+		let start = end;
+		while (start >= 0 && isIdentifierChar(code[start])) start--;
+		if (GLOBAL_OBJECTS.has(code.slice(start + 1, end + 1))) found.push(at);
+	}
+	return found;
+};
+/** The identifier ending at or before `end` (skipping whitespace); `""` when it is itself a member access. */
+const wordEndingAt = (code, end) => {
+	let j = end;
+	while (j >= 0 && SPACE.test(code[j] ?? "")) j--;
+	let start = j;
+	while (start >= 0 && isIdentifierChar(code[start])) start--;
+	return code[start] === "." ? "" : code.slice(start + 1, j + 1);
+};
+/**
+* The literals that are module specifiers: after `from` or `import`, or the
+* whole first argument of `import(` or `require(` (followed by `)` or `,`, so
+* `import("./x" + name)` is not read as `"./x"`).
+*/
+const specifierLiterals = (lexed) => lexed.literals.filter((literal) => {
+	let j = literal.start - 1;
+	while (j >= 0 && SPACE.test(lexed.code[j] ?? "")) j--;
+	if (lexed.code[j] === "(") {
+		const callee = wordEndingAt(lexed.code, j - 1);
+		if (callee !== "import" && callee !== "require") return false;
+		let k = literal.start + literal.value.length + 2;
+		while (k < lexed.code.length && SPACE.test(lexed.code[k] ?? "")) k++;
+		return lexed.code[k] === ")" || lexed.code[k] === ",";
+	}
+	const keyword = wordEndingAt(lexed.code, j);
+	return keyword === "from" || keyword === "import";
+});
+/** A lookup from an offset in `text` to its 1-based line and UTF-16 column. */
+const locate = (text) => {
+	const starts = [0];
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+	return (offset) => {
+		let low = 0;
+		let high = starts.length - 1;
+		while (low < high) {
+			const middle = low + high + 1 >> 1;
+			if ((starts[middle] ?? 0) <= offset) low = middle;
+			else high = middle - 1;
+		}
+		return {
+			line: low + 1,
+			column: offset - (starts[low] ?? 0) + 1
+		};
+	};
+};
+
+//#endregion
+export { isIdentifierChar, lex, locate, references, specifierLiterals };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.25.0",
+	"version": "0.26.0",
 	"private": false,
 	"description": "Monorepo workspace tooling as Effect services — root discovery, package enumeration, the dependency graph, package-manager detection, pnpm catalog resolution, lockfile IO and git-based change detection.",
 	"keywords": [
@@ -43,6 +43,11 @@
 			"import": "./node-sync.js",
 			"default": "./node-sync.js"
 		},
+		"./testing": {
+			"types": "./testing.d.ts",
+			"import": "./testing.js",
+			"default": "./testing.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"dependencies": {