glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/ingest-editor-core-BuI1gMF_.js

@@ -0,0 +1,445 @@
+//#region server/core/visions-buffer-core.ts
+function createDocStore() {
+	return { docsByUri: Object.create(null) };
+}
+function uriOfParams(params) {
+	const uri = params?.textDocument?.uri;
+	if (typeof uri === "string" && uri !== "") return uri;
+	return null;
+}
+function applyDidOpen(store, params) {
+	const textDocument = params?.textDocument;
+	if (!textDocument || typeof textDocument.uri !== "string" || !textDocument.uri) return {
+		applied: false,
+		reason: "invalid-params"
+	};
+	store.docsByUri[textDocument.uri] = {
+		uri: textDocument.uri,
+		languageId: typeof textDocument.languageId === "string" ? textDocument.languageId : "",
+		version: Number(textDocument.version),
+		text: typeof textDocument.text === "string" ? textDocument.text : ""
+	};
+	return { applied: true };
+}
+function lineStartOffsets(text) {
+	const starts = [0];
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (char === "\n") starts.push(index + 1);
+		if (char === "\r" && text[index + 1] !== "\n") starts.push(index + 1);
+	}
+	return starts;
+}
+function lineOfOffset(lineStarts, offset) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if (lineStarts[middle] <= offset) {
+			low = middle;
+			continue;
+		}
+		high = middle - 1;
+	}
+	return low + 1;
+}
+function isPositionShape(position) {
+	if (!position || typeof position !== "object") return false;
+	const candidate = position;
+	if (typeof candidate.line !== "number" || !Number.isInteger(candidate.line) || candidate.line < 0) return false;
+	return typeof candidate.character === "number" && Number.isInteger(candidate.character) && candidate.character >= 0;
+}
+function lineEndBeforeBreak(text, nextLineStart) {
+	const breakIndex = nextLineStart - 1;
+	if (breakIndex > 0 && text[breakIndex] === "\n" && text[breakIndex - 1] === "\r") return breakIndex - 1;
+	return breakIndex;
+}
+function offsetOfPosition(text, lineStarts, position) {
+	if (position.line >= lineStarts.length) return text.length;
+	const lineStart = lineStarts[position.line];
+	const nextLineStart = lineStarts[position.line + 1];
+	const lineEnd = nextLineStart === void 0 ? text.length : lineEndBeforeBreak(text, nextLineStart);
+	return Math.min(lineStart + position.character, lineEnd);
+}
+function applyContentChange(text, change) {
+	if (!change || typeof change !== "object") return {
+		ok: false,
+		reason: "invalid-range"
+	};
+	if (change.range === void 0 || change.range === null) return {
+		ok: true,
+		text: typeof change.text === "string" ? change.text : ""
+	};
+	const { range } = change;
+	if (typeof range !== "object" || !isPositionShape(range.start) || !isPositionShape(range.end)) return {
+		ok: false,
+		reason: "invalid-range"
+	};
+	if (typeof change.text !== "string") return {
+		ok: false,
+		reason: "invalid-text"
+	};
+	const lineStarts = lineStartOffsets(text);
+	const start = offsetOfPosition(text, lineStarts, range.start);
+	const end = offsetOfPosition(text, lineStarts, range.end);
+	if (start > end) return {
+		ok: false,
+		reason: "invalid-range"
+	};
+	return {
+		ok: true,
+		text: text.slice(0, start) + change.text + text.slice(end)
+	};
+}
+function formatRange(range) {
+	if (!range || typeof range !== "object") return "<none>";
+	return `${formatPosition(range.start)}-${formatPosition(range.end)}`;
+}
+function formatPosition(position) {
+	if (!position || typeof position !== "object") return "?";
+	return `${position.line}:${position.character}`;
+}
+function applyDidChange(store, params) {
+	const textDocument = params?.textDocument;
+	const uri = typeof textDocument?.uri === "string" ? textDocument.uri : "";
+	const doc = uri ? store.docsByUri[uri] : null;
+	if (!doc) return {
+		applied: false,
+		reason: "unknown-uri"
+	};
+	const version = textDocument?.version;
+	if (typeof version !== "number" || !Number.isFinite(version)) return {
+		applied: false,
+		reason: "invalid-version"
+	};
+	if (typeof doc.version === "number" && version <= doc.version) return {
+		applied: false,
+		reason: "stale-version",
+		version,
+		currentVersion: doc.version
+	};
+	const changes = Array.isArray(params?.contentChanges) ? params.contentChanges : [];
+	let text = doc.text;
+	const applied = [];
+	for (let index = 0; index < changes.length; index += 1) {
+		const change = changes[index];
+		const spliced = applyContentChange(text, change);
+		if (!spliced.ok) return {
+			applied: false,
+			reason: spliced.reason,
+			index,
+			range: change?.range ?? null
+		};
+		applied.push({
+			change,
+			textBefore: text
+		});
+		text = spliced.text;
+	}
+	store.docsByUri[uri] = {
+		uri,
+		languageId: doc.languageId,
+		version,
+		text
+	};
+	return {
+		applied: true,
+		changeCount: changes.length,
+		size: text.length,
+		changes: applied
+	};
+}
+function isNewlineWithOptionalIndent(text) {
+	return typeof text === "string" && /^\r?\n[ \t]*$/.test(text);
+}
+function isLineBlankAtOffset(text, offset) {
+	const lineStarts = lineStartOffsets(text);
+	let lineIndex = lineStarts.length - 1;
+	for (let index = 0; index < lineStarts.length; index += 1) {
+		const nextLineStart = lineStarts[index + 1];
+		if (nextLineStart !== void 0 && offset >= nextLineStart) continue;
+		lineIndex = index;
+		break;
+	}
+	const lineStart = lineStarts[lineIndex];
+	const nextLineStart = lineStarts[lineIndex + 1];
+	const lineEnd = nextLineStart === void 0 ? text.length : lineEndBeforeBreak(text, nextLineStart);
+	return /^[ \t]*$/.test(text.slice(lineStart, lineEnd));
+}
+function isBoundaryInsertion(previousText, nextText, insertionOffset, insertedText) {
+	if (!isNewlineWithOptionalIndent(insertedText)) return false;
+	if (nextText !== previousText.slice(0, insertionOffset) + insertedText + previousText.slice(insertionOffset)) return false;
+	return isLineBlankAtOffset(nextText, insertionOffset + insertedText.length);
+}
+function movedTextRotatedToLineStart({ previousText, offset, movedText }) {
+	const lineStarts = lineStartOffsets(previousText);
+	let rotatedOffset = offset;
+	let rotatedText = movedText;
+	while (rotatedOffset > 0 && !lineStarts.includes(rotatedOffset)) {
+		const lastMovedChar = rotatedText.at(-1);
+		if (lastMovedChar === void 0 || previousText[rotatedOffset - 1] !== lastMovedChar) break;
+		rotatedText = `${lastMovedChar}${rotatedText.slice(0, -1)}`;
+		rotatedOffset -= 1;
+	}
+	return {
+		offset: rotatedOffset,
+		movedText: rotatedText
+	};
+}
+function commonAffixSpan(previousText, nextText) {
+	let prefixLength = 0;
+	while (prefixLength < previousText.length && prefixLength < nextText.length && previousText[prefixLength] === nextText[prefixLength]) prefixLength += 1;
+	let suffixLength = 0;
+	while (suffixLength < previousText.length - prefixLength && suffixLength < nextText.length - prefixLength && previousText[previousText.length - 1 - suffixLength] === nextText[nextText.length - 1 - suffixLength]) suffixLength += 1;
+	return {
+		offset: prefixLength,
+		removedText: previousText.slice(prefixLength, previousText.length - suffixLength),
+		insertedText: nextText.slice(prefixLength, nextText.length - suffixLength)
+	};
+}
+function replacedSpanOfWholeTextChange(previousText, nextText) {
+	if (typeof previousText !== "string" || typeof nextText !== "string") return null;
+	if (previousText === nextText) return null;
+	const { offset, removedText, insertedText } = commonAffixSpan(previousText, nextText);
+	if (removedText !== "" && insertedText !== "") return {
+		offset,
+		removedText,
+		insertedText
+	};
+	const rotated = movedTextRotatedToLineStart({
+		previousText,
+		offset,
+		movedText: removedText || insertedText
+	});
+	if (removedText === "") return {
+		offset: rotated.offset,
+		removedText: "",
+		insertedText: rotated.movedText
+	};
+	return {
+		offset: rotated.offset,
+		removedText: rotated.movedText,
+		insertedText: ""
+	};
+}
+function insertionFromWholeTextChange(previousText, nextText) {
+	if (nextText.length <= previousText.length) return null;
+	const span = commonAffixSpan(previousText, nextText);
+	if (span.removedText !== "") return null;
+	return {
+		offset: span.offset,
+		text: span.insertedText
+	};
+}
+function detectBlankLineBoundary({ previousText, nextText, changes }) {
+	if (typeof previousText !== "string" || typeof nextText !== "string") return false;
+	if (previousText === nextText) return false;
+	if (!Array.isArray(changes) || changes.length !== 1) return false;
+	const [change] = changes;
+	if (!change || typeof change !== "object") return false;
+	if (change.range === void 0 || change.range === null) {
+		const insertion = insertionFromWholeTextChange(previousText, nextText);
+		if (!insertion) return false;
+		return isBoundaryInsertion(previousText, nextText, insertion.offset, insertion.text);
+	}
+	const { range } = change;
+	if (typeof range !== "object" || !isPositionShape(range.start) || !isPositionShape(range.end)) return false;
+	if (range.start.line !== range.end.line || range.start.character !== range.end.character) return false;
+	return isBoundaryInsertion(previousText, nextText, offsetOfPosition(previousText, lineStartOffsets(previousText), range.start), change.text);
+}
+function applyDidClose(store, params) {
+	const textDocument = params?.textDocument;
+	const uri = typeof textDocument?.uri === "string" ? textDocument.uri : "";
+	if (!uri || !store.docsByUri[uri]) return {
+		applied: false,
+		reason: "unknown-uri"
+	};
+	delete store.docsByUri[uri];
+	return { applied: true };
+}
+function getDoc(store, uri) {
+	const doc = store.docsByUri[uri];
+	if (!doc) return null;
+	return {
+		uri: doc.uri,
+		languageId: doc.languageId,
+		version: doc.version,
+		text: doc.text
+	};
+}
+function listDocs(store) {
+	return Object.keys(store.docsByUri).map((uri) => getDoc(store, uri));
+}
+//#endregion
+//#region server/core/visions-scope-core.ts
+function collapseDotSegments(value) {
+	const out = [];
+	for (const part of value.split("/")) {
+		if (part === ".") continue;
+		if (part === ".." && out.length > 0 && out[out.length - 1] !== ".." && out[out.length - 1] !== "") {
+			out.pop();
+			continue;
+		}
+		if (part === ".." && out.length === 1 && out[0] === "") continue;
+		out.push(part);
+	}
+	return out.join("/");
+}
+function normalizeShapePath(input) {
+	const raw = String(input == null ? "" : input).trim();
+	if (!raw) return "";
+	let normalized = raw.replace(/\\/g, "/");
+	const isUnc = normalized.startsWith("//");
+	normalized = collapseDotSegments(normalized.replace(/\/{2,}/g, "/"));
+	if (isUnc) normalized = `/${normalized}`;
+	if (normalized.length > 1) normalized = normalized.replace(/\/+$/, "");
+	if (isUnc || /^[a-zA-Z]:($|\/)/.test(normalized)) return normalized.toLowerCase();
+	return normalized;
+}
+function pathOfFileUri(uri) {
+	if (typeof uri !== "string" || !uri) return null;
+	let parsed;
+	try {
+		parsed = new URL(uri);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "file:") return null;
+	let pathname = "";
+	try {
+		pathname = decodeURIComponent(parsed.pathname || "");
+	} catch {
+		return null;
+	}
+	if (parsed.hostname) return normalizeShapePath(`//${parsed.hostname}${pathname}`);
+	const drivePath = pathname.match(/^\/([a-zA-Z]:)(\/.*|$)/);
+	if (drivePath) return normalizeShapePath(`${drivePath[1]}${drivePath[2]}`);
+	return normalizeShapePath(pathname);
+}
+function isWithin(scopePath, uriPath, foldCase = false) {
+	if (!scopePath || !uriPath) return false;
+	const scopeKey = foldCase ? scopePath.toLowerCase() : scopePath;
+	const uriKey = foldCase ? uriPath.toLowerCase() : uriPath;
+	if (uriKey === scopeKey) return true;
+	const prefix = scopeKey.endsWith("/") ? scopeKey : `${scopeKey}/`;
+	return uriKey.startsWith(prefix);
+}
+function isUriInProjects(uri, normalizedProjectPaths, foldCase = false) {
+	const uriPath = pathOfFileUri(uri);
+	if (!uriPath) return false;
+	return (Array.isArray(normalizedProjectPaths) ? normalizedProjectPaths : []).some((scopePath) => isWithin(scopePath, uriPath, foldCase));
+}
+function deepestRootFor(normalizedPath, roots, foldCase = false) {
+	let owner = null;
+	for (const raw of Array.isArray(roots) ? roots : []) {
+		const root = normalizeShapePath(raw);
+		if (!isWithin(root, normalizedPath, foldCase)) continue;
+		if (owner && owner.length >= root.length) continue;
+		owner = root;
+	}
+	return owner;
+}
+function projectForUri(uri, scopeProjects, foldCase = false) {
+	if (!Array.isArray(scopeProjects) || scopeProjects.length === 0) return null;
+	const uriPath = pathOfFileUri(uri);
+	if (!uriPath) return null;
+	const owned = scopeProjects.filter((entry) => Boolean(entry) && typeof entry.id === "string" && entry.id !== "").map((entry) => ({
+		id: entry.id,
+		path: normalizeShapePath(entry.path)
+	}));
+	const root = deepestRootFor(uriPath, owned.map((entry) => entry.path), foldCase);
+	const owner = owned.find((entry) => entry.path === root);
+	return owner ? owner.id : null;
+}
+function scopePathsOf(scopeProjects) {
+	const paths = [];
+	for (const entry of Array.isArray(scopeProjects) ? scopeProjects : []) {
+		const scopePath = normalizeShapePath(entry?.path);
+		if (!scopePath || paths.includes(scopePath)) continue;
+		paths.push(scopePath);
+	}
+	return paths;
+}
+function resolveVisionsScopeProjects({ configuredIds, projects, warn }) {
+	const usable = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const project of Array.isArray(projects) ? projects : []) {
+		if (!project || typeof project.id !== "string" || project.id === "") continue;
+		const normalizedPath = normalizeShapePath(project.path);
+		if (!normalizedPath || seenPaths.has(normalizedPath)) continue;
+		seenPaths.add(normalizedPath);
+		usable.push({
+			id: project.id,
+			path: normalizedPath
+		});
+	}
+	const ids = Array.isArray(configuredIds) ? configuredIds.filter((id) => typeof id === "string" && id !== "") : [];
+	if (ids.length === 0) return usable;
+	const wanted = new Set(ids);
+	for (const id of ids) if (!usable.some((project) => project.id === id)) warn(`[visions] configured project id not found or has no usable path: ${id}`);
+	return usable.filter((project) => wanted.has(project.id));
+}
+//#endregion
+//#region server/core/ingest-editor-core.ts
+var SOURCE = "editor";
+var ACTIVITY_METHOD = "visions/editorActivity";
+var KIND_BY_METHOD = Object.freeze({
+	"textDocument/didOpen": "doc-open",
+	"textDocument/didSave": "doc-save",
+	"textDocument/didClose": "doc-close"
+});
+var VERB_BY_KIND = Object.freeze({
+	"doc-open": "opened",
+	"doc-save": "saved",
+	"doc-close": "closed"
+});
+function createEditorState() {
+	return { openUris: /* @__PURE__ */ new Set() };
+}
+function relativeTo(root, normalizedPath) {
+	if (!root || root === normalizedPath) return normalizedPath.split("/").pop() || normalizedPath;
+	return normalizedPath.slice(root.length + 1);
+}
+function applyEditorNotification(state, { method, uri, roots = [], foldCase = false, now = 0 } = {}) {
+	if (typeof method !== "string" || typeof uri !== "string") return {
+		state,
+		event: null
+	};
+	const kind = KIND_BY_METHOD[method];
+	if (!kind) return {
+		state,
+		event: null
+	};
+	const normalizedPath = normalizeShapePath(pathOfFileUri(uri));
+	if (!normalizedPath) return {
+		state,
+		event: null
+	};
+	if (kind === "doc-open" && state.openUris.has(uri)) return {
+		state,
+		event: null
+	};
+	if (kind === "doc-close" && !state.openUris.has(uri)) return {
+		state,
+		event: null
+	};
+	if (kind === "doc-open") state.openUris.add(uri);
+	if (kind === "doc-close") state.openUris.delete(uri);
+	const root = deepestRootFor(normalizedPath, roots, foldCase);
+	return {
+		state,
+		event: {
+			source: SOURCE,
+			kind,
+			ts: now,
+			scope: {
+				root: root || null,
+				sessionId: null
+			},
+			summary: `${VERB_BY_KIND[kind]} ${relativeTo(root, normalizedPath)}`,
+			detail: { path: relativeTo(root, normalizedPath) }
+		}
+	};
+}
+//#endregion
+export { listDocs as _, projectForUri as a, uriOfParams as b, applyDidChange as c, createDocStore as d, detectBlankLineBoundary as f, lineStartOffsets as g, lineOfOffset as h, isUriInProjects as i, applyDidClose as l, getDoc as m, applyEditorNotification as n, resolveVisionsScopeProjects as o, formatRange as p, createEditorState as r, scopePathsOf as s, ACTIVITY_METHOD as t, applyDidOpen as u, offsetOfPosition as v, replacedSpanOfWholeTextChange as y };

package/dist/chunks/loopback-post-C7C22eYi.js

@@ -0,0 +1,79 @@
+import "./hook-relay-core-BHfYFnYV.js";
+import http from "node:http";
+//#region session/loopback-post.ts
+var POST_TIMEOUT_MS = 1500;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"::1",
+	"[::1]",
+	"localhost"
+]);
+function postToLoopback(url, body) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const done = (reason, responseBody = null) => {
+			if (settled) return;
+			settled = true;
+			resolve({
+				reason,
+				responseBody
+			});
+		};
+		let target;
+		try {
+			target = new URL(url);
+		} catch {
+			done("bad-url");
+			return;
+		}
+		if (target.protocol !== "http:") {
+			done("not-http");
+			return;
+		}
+		if (!LOOPBACK_HOSTS.has(target.hostname)) {
+			done("not-loopback");
+			return;
+		}
+		try {
+			const request = http.request({
+				hostname: target.hostname,
+				port: target.port,
+				path: `${target.pathname}${target.search}`,
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"content-length": Buffer.byteLength(body)
+				}
+			}, (response) => {
+				const chunks = [];
+				let responseBytes = 0;
+				response.on("data", (chunk) => {
+					if (settled) return;
+					responseBytes += chunk.length;
+					if (responseBytes > 65536) {
+						response.destroy();
+						done("response-too-large");
+						return;
+					}
+					chunks.push(chunk);
+				});
+				response.on("end", () => done(`status-${response.statusCode}`, Buffer.concat(chunks).toString("utf8")));
+				response.on("error", () => done("response-error"));
+				response.on("close", () => done("response-error"));
+			});
+			request.on("error", () => done("request-error"));
+			request.setTimeout(POST_TIMEOUT_MS, () => {
+				request.destroy();
+				done("timeout");
+			});
+			request.end(body);
+		} catch {
+			done("request-throw");
+		}
+	});
+}
+async function postPayload(url, body) {
+	return (await postToLoopback(url, body)).responseBody;
+}
+//#endregion
+export { postToLoopback as n, postPayload as t };