@sanity-labs/groq-content-mapper 0.0.0 → 0.1.1

package/dist/contentMapper-BMNwbuMF.js

@@ -0,0 +1,896 @@
+import { createHash } from "node:crypto";
+import path, { dirname, isAbsolute, resolve, sep } from "node:path";
+import "node:stream";
+import * as v from "valibot";
+import * as t from "@babel/types";
+import { GroqSyntaxError, parse, typeEvaluate } from "groq-js";
+import { CodeGenerator } from "@babel/generator";
+import * as codegen from "@sanity/codegen";
+import { readFile } from "node:fs/promises";
+/**
+* Names `@sanity/codegen` gives the helpers a schema type can refer to. A module that refers to
+* one declares it locally, as `sanity.types.ts` does.
+*/
+const ARRAY_OF = "ArrayOf", INTERNAL_REFERENCE_SYMBOL = "internalGroqTypeReferenceTo", RESERVED_IDENTIFIERS = /* @__PURE__ */ new Set([
+	"AllSanitySchemaTypes",
+	ARRAY_OF,
+	INTERNAL_REFERENCE_SYMBOL,
+	"SanityQueries"
+]);
+/** `filename` relative to `root`, with forward slashes on every platform. */
+function normalizePrintablePath(root, filename) {
+	return path.relative(root, path.resolve(root, filename)).replaceAll("\\", "/");
+}
+/** Whether a string is a valid ECMAScript IdentifierName. */
+function isIdentifierName(input) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(input);
+}
+/** A PascalCase identifier for `name` that is not in `taken`, suffixed `_2`, `_3`… as needed. */
+function getUniqueIdentifierForName(name, taken) {
+	let sanitized = name.replace(/^\d/, "_").replaceAll(/[^$\w]+(.)/g, (_, char) => char.toUpperCase()), desired = `${sanitized.charAt(0).toUpperCase()}${sanitized.slice(1)}`, resulting = desired;
+	for (let index = 2; taken.has(resulting) || RESERVED_IDENTIFIERS.has(resulting); index++) resulting = `${desired}_${index}`;
+	return t.identifier(resulting);
+}
+function generateCode(node) {
+	return `${new CodeGenerator(node).generate().code.trim()}\n\n`;
+}
+function getMessage(error) {
+	return typeof error == "object" && error && "message" in error && typeof error.message == "string" ? error.message : "Unknown error";
+}
+/**
+* Parses a GROQ query for type evaluation. groq-js only accepts constant slice bounds, so a
+* `$param` used as one is bound to `0` first: the value does not matter for its type. Not for
+* queries that are executed.
+*/
+function safeParseQuery(query) {
+	let params = {};
+	for (let param of extractSliceParams(query)) params[param] = 0;
+	return parse(query, { params });
+}
+/** The names of the `$params` used as slice bounds, as in `[$start...$end]` or `[10..$end]`. */
+function* extractSliceParams(query) {
+	for (let match of query.matchAll(/\[\s*(\$(\w+)|\d+)\s*\.\.\.?\s*(\$(\w+)|\d+)\s*\]/g)) match[1] === `$${match[2]}` && (yield match[2]), match[3] === `$${match[4]}` && (yield match[4]);
+}
+/** The attribute a probe projection writes the counterpart's type to. */
+const PROBE = "__sanityGroqParam", UNKNOWN = { type: "unknown" }, PARAMETER = /\$([A-Za-z_]\w*)/g, ROOT = {
+	depth: 0,
+	wrap: (expr) => expr
+};
+/**
+* The type of every `$param` in a query, in order of first appearance.
+*
+* A placeholder compared with a field takes the field's type: `slug.current == $slug` is
+* `string`, `role == $role` keeps a string enum, `tags == $tags` is `Array<string>`,
+* `$tag in tags` is `string`, `_id in $ids` is `Array<string>`, and `title match $term` is
+* `string`. Slice bounds are `number`. Field types come from groq-js's own type evaluation, so
+* dereferences, `_type` narrowing in a filter, nested scopes and inline types resolve as they do
+* for the result type. A placeholder compared with a literal widens to the literal's primitive.
+* One that is only passed to a function or projected is `unknown`, and still required.
+*
+* @param ast - The query as `safeParseQuery` parsed it, so slice bounds are already constants
+*/
+function inferParams({ ast, query, schema }) {
+	let found = {
+		comparisons: [],
+		names: /* @__PURE__ */ new Set()
+	};
+	walk(ast, ROOT, found);
+	let code = withoutLiterals(query), types = /* @__PURE__ */ new Map();
+	for (let name of extractSliceParams(code)) types.set(name, [{ type: "number" }]);
+	for (let name of found.names) types.set(name, types.get(name) ?? []);
+	for (let comparison of found.comparisons) {
+		let type = resolve$1(comparison, schema);
+		type && types.get(comparison.name)?.push(type);
+	}
+	let params = /* @__PURE__ */ new Map(), inOrder = [...code.matchAll(PARAMETER)].map((match) => match[1]);
+	for (let name of [...inOrder, ...types.keys()]) {
+		let candidates = types.get(name);
+		candidates && !params.has(name) && params.set(name, combine(candidates));
+	}
+	return params;
+}
+function walk(node, scope, found) {
+	switch (node.type) {
+		case "Filter":
+			walk(node.base, scope, found), walk(node.expr, nested(scope, (probe) => mapElements(node, probe)), found);
+			return;
+		case "FlatMap":
+		case "Map":
+			walk(node.base, scope, found), walk(node.expr, nested(scope, (probe) => ({
+				...node,
+				expr: probe
+			})), found);
+			return;
+		case "InRange":
+			noteRange(node, scope, found);
+			break;
+		case "OpCall":
+			noteComparison(node, scope, found);
+			break;
+		case "Parameter":
+			found.names.add(node.name);
+			return;
+		case "PipeFuncCall": {
+			walk(node.base, scope, found);
+			let inner = nested(scope, (probe) => mapElements(node.base, probe));
+			for (let arg of node.args) walk(arg, inner, found);
+			return;
+		}
+		case "Projection": {
+			walk(node.base, scope, found);
+			let inner = node.base.type === "This" ? scope : nested(scope, (probe) => ({
+				...node,
+				expr: probe
+			}));
+			walk(node.expr, inner, found);
+			return;
+		}
+	}
+	for (let child of children(node)) walk(child, scope, found);
+}
+function nested(scope, build) {
+	return {
+		depth: scope.depth + 1,
+		wrap: (expr) => scope.wrap(build({
+			attributes: [{
+				name: PROBE,
+				type: "ObjectAttributeValue",
+				value: expr
+			}],
+			type: "Object"
+		}))
+	};
+}
+/** The probe evaluated once per element of `base`, whether the elements are objects or not. */
+function mapElements(base, probe) {
+	return {
+		base,
+		expr: probe,
+		type: "Map"
+	};
+}
+function noteComparison(node, scope, found) {
+	let left = asParameter(node.left), right = asParameter(node.right);
+	!!left != !!right && found.comparisons.push({
+		counterpart: left ? node.right : node.left,
+		name: (left ?? right).name,
+		op: node.op,
+		paramOnLeft: !!left,
+		scope
+	});
+}
+function noteRange(node, scope, found) {
+	for (let bound of [node.left, node.right]) {
+		let param = asParameter(bound);
+		param && found.comparisons.push({
+			counterpart: node.base,
+			name: param.name,
+			op: "range",
+			paramOnLeft: !0,
+			scope
+		});
+	}
+}
+function asParameter(node) {
+	return node.type === "Group" ? asParameter(node.base) : node.type === "Parameter" ? node : void 0;
+}
+function resolve$1({ counterpart, op, paramOnLeft, scope }, schema) {
+	if (op === "match") return { type: "string" };
+	let expr = unwrapGroups(counterpart);
+	if (some(expr, (node) => node.type === "Parent")) return;
+	let probed = probe(scope, expr, schema);
+	if (!probed) return;
+	let type = expr.type === "Value" ? widen(probed) : withoutNull(probed);
+	if (type.type !== "null" || expr.type === "Value") return op === "in" ? paramOnLeft ? withoutNull(elementOf(type)) : {
+		of: type,
+		type: "array"
+	} : type;
+}
+/** Evaluates `expr` in `scope`, or `undefined` when the probe cannot be typed. */
+function probe(scope, expr, schema) {
+	let evaluated;
+	try {
+		evaluated = typeEvaluate(scope.wrap(expr), schema);
+	} catch {
+		return;
+	}
+	let types = dig(evaluated, scope.depth);
+	return types.length > 0 ? union(types) : void 0;
+}
+/** Reads the probe attribute `depth` levels down, through the arrays and unions on the way. */
+function dig(type, depth) {
+	if (depth === 0) return [type];
+	switch (type.type) {
+		case "array": return dig(type.of, depth);
+		case "boolean":
+		case "inline":
+		case "null":
+		case "number":
+		case "string": return [];
+		case "object": {
+			let attribute = type.attributes[PROBE];
+			return attribute ? dig(attribute.value, depth - 1) : [];
+		}
+		case "union": return type.of.flatMap((member) => dig(member, depth));
+		case "unknown": return [type];
+		default: throw Error(`Unexpected type node ${JSON.stringify(type)}`);
+	}
+}
+/** One type per parameter: the union of what its comparisons say, or `unknown` if nothing does. */
+function combine(types) {
+	let known = types.flatMap((type) => members(type)).filter((type) => type.type !== "unknown");
+	return known.length > 0 ? union(known) : UNKNOWN;
+}
+function members(type) {
+	return type.type === "union" ? type.of.flatMap((member) => members(member)) : [type];
+}
+function union(types) {
+	let unique = /* @__PURE__ */ new Map();
+	for (let type of types.flatMap((member) => members(member))) unique.set(JSON.stringify(type), type);
+	let of = [...unique.values()];
+	return of.length === 1 ? of[0] : {
+		of,
+		type: "union"
+	};
+}
+function withoutNull(type) {
+	let of = members(type).filter((member) => member.type !== "null");
+	return of.length > 0 ? union(of) : type;
+}
+function elementOf(type) {
+	return union(members(type).map((member) => member.type === "array" ? member.of : member));
+}
+function widen(type) {
+	return union(members(type).map((member) => member.type === "string" || member.type === "number" || member.type === "boolean" ? { type: member.type } : member));
+}
+function unwrapGroups(node) {
+	return node.type === "Group" ? unwrapGroups(node.base) : node;
+}
+function some(node, predicate) {
+	return predicate(node) || children(node).some((child) => some(child, predicate));
+}
+function children(node) {
+	switch (node.type) {
+		case "AccessAttribute": return node.base ? [node.base] : [];
+		case "AccessElement":
+		case "ArrayCoerce":
+		case "Asc":
+		case "Deref":
+		case "Desc":
+		case "Group":
+		case "Neg":
+		case "Not":
+		case "Pos":
+		case "Slice": return [node.base];
+		case "And":
+		case "OpCall":
+		case "Or": return [node.left, node.right];
+		case "Array": return node.elements.map((element) => element.value);
+		case "Context":
+		case "Everything":
+		case "Parameter":
+		case "Parent":
+		case "This":
+		case "Value": return [];
+		case "Filter":
+		case "FlatMap":
+		case "Map":
+		case "Projection": return [node.base, node.expr];
+		case "FuncCall": return node.args;
+		case "InRange": return [
+			node.base,
+			node.left,
+			node.right
+		];
+		case "Object": return node.attributes.flatMap((attribute) => attribute.type === "ObjectConditionalSplat" ? [attribute.condition, attribute.value] : [attribute.value]);
+		case "PipeFuncCall": return [node.base, ...node.args];
+		case "Select": return [...node.alternatives.flatMap((alternative) => [alternative.condition, alternative.value]), ...node.fallback ? [node.fallback] : []];
+		case "SelectorFuncCall": return [node.arg];
+		case "SelectorNested": return [node.base, node.nested];
+		case "Tuple": return node.members;
+		default: throw Error(`Unexpected GROQ node ${JSON.stringify(node)}`);
+	}
+}
+/**
+* The query with the contents of string literals and comments blanked out, at the same
+* positions, so a `$name` or a slice inside them is neither read nor hides a real one.
+*/
+function withoutLiterals(query) {
+	let code = "", quote;
+	for (let index = 0; index < query.length; index++) {
+		let char = query[index];
+		if (quote) char === "\\" ? (code += "  ", index++) : char === quote ? (quote = void 0, code += char) : code += " ";
+		else if (char === "\"" || char === "'") quote = char, code += char;
+		else if (char === "/" && query[index + 1] === "/") {
+			let end = query.indexOf("\n", index), length = (end === -1 ? query.length : end) - index;
+			code += " ".repeat(length), index += length - 1;
+		} else code += char;
+	}
+	return code;
+}
+const cache = /* @__PURE__ */ new WeakMap();
+/** The schema's types, computed once per schema object. */
+function schemaTypesFor(schema) {
+	let schemaTypes = cache.get(schema);
+	return schemaTypes || cache.set(schema, schemaTypes = createSchemaTypes(schema)), schemaTypes;
+}
+/**
+* `@sanity/codegen` 8.2 does not export `SchemaTypeGenerator`, and keeps `generateTsType` and
+* the selector that builds one private to TypeScript only. Until it exports the class, the
+* instance `TypeGenerator` builds for `generateTypes` is used, which is the same object.
+*/
+function createSchemaTypes(schema) {
+	let exported = codegen.SchemaTypeGenerator;
+	if (exported) return new exported(schema);
+	let schemaTypes = new codegen.TypeGenerator().getSchemaTypeGenerator?.({ schema });
+	if (typeof schemaTypes?.generateTsType != "function") throw TypeError("This version of @sanity/codegen does not provide SchemaTypeGenerator. Install @sanity/codegen 8.2 or later.");
+	return schemaTypes;
+}
+/** The type exports of every typed `.groq` module. */
+const QUERY_RESPONSE = "QueryResponse", QUERY_PARAMS = "QueryParams", MODULE_NAMES = /* @__PURE__ */ new Set([
+	"query",
+	QUERY_PARAMS,
+	QUERY_RESPONSE
+]), GroqFileDiagnosticCode = {
+	/** The file holds no query. */
+	EmptyFile: 1,
+	/** groq-js could not evaluate the query against the schema. */
+	EvaluationFailed: 4,
+	/** No schema to type the query against. */
+	SchemaUnavailable: 3,
+	/** The query does not parse. `start` points at the error. */
+	SyntaxError: 2
+};
+/**
+* Types one `.groq` file as a TypeScript module, so a text import of the file,
+* `import query from './file.groq' with {type: 'text'}`, gives a query string that carries
+* its own types:
+*
+* ```ts
+* export type QueryResponse = Array<{title: string | null}>
+* export type QueryParams = {slug: string}
+* declare const query: '*[_type == "post" && slug.current == $slug]{title}\n' & {
+*   readonly __groqResult?: QueryResponse
+*   readonly __groqParams?: QueryParams
+* }
+* export default query
+* ```
+*
+* The literal is the file's exact content, whitespace and all, because that is what a text
+* import evaluates to at run time; GROQ does not mind the whitespace. The result type is
+* evaluated as `@sanity/codegen` evaluates a `defineQuery` call, so `[0]` becomes `T | null`.
+* Params are inferred from the `$` placeholders: a placeholder compared with a field takes the
+* field's type, slice bounds are numbers, and anything else is `unknown`.
+*
+* A file that cannot be typed still yields a complete module, with `unknown` for what could
+* not be inferred, plus a diagnostic saying why. The schema's type aliases are computed once
+* per schema object.
+* @beta
+*/
+function generateGroqModule(options) {
+	let { content, filename, root, schema, schemaPath } = options, query = content, diagnostics = [], notes = [], report = (code, messageText, start, length) => {
+		let from = Math.min(start, content.length);
+		diagnostics.push({
+			code,
+			length: Math.min(length, content.length - from),
+			messageText,
+			start: from
+		});
+	}, render = (parts) => ({
+		...renderGroqModule({
+			filename,
+			notes,
+			query,
+			root,
+			schemaPath,
+			...parts
+		}),
+		diagnostics,
+		query
+	});
+	if (query.trim().length === 0) return report(GroqFileDiagnosticCode.EmptyFile, "This .groq file has no query.", 0, content.length), render({});
+	let ast;
+	try {
+		ast = safeParseQuery(query);
+	} catch (error) {
+		let position = error instanceof GroqSyntaxError ? error.position : 0;
+		return report(GroqFileDiagnosticCode.SyntaxError, getMessage(error), position, 1), render({});
+	}
+	try {
+		let schemaTypes = schemaTypesFor(schema), params = /* @__PURE__ */ new Map();
+		for (let [name, type] of inferParams({
+			ast,
+			query,
+			schema
+		})) params.set(name, schemaTypes.generateTsType(type));
+		let tsType = schemaTypes.generateTsType(typeEvaluate(ast, schema));
+		return render({
+			params: paramsType(params),
+			result: {
+				schemaTypes,
+				tsType
+			}
+		});
+	} catch (error) {
+		let message = `Could not type this query against the schema: ${getMessage(error)}`;
+		return report(GroqFileDiagnosticCode.EvaluationFailed, message, 0, query.length), notes.push(message), render({});
+	}
+}
+/**
+* The TypeScript module for a `.groq` file.
+*
+* The module is self-contained. Only the schema type aliases the result and params refer to are
+* declared, as module-local types, so a projection carries no schema at all and two files with
+* the same query text are interchangeable.
+*/
+function renderGroqModule(options) {
+	let { filename, notes, query, result, root = process.cwd(), schemaPath } = options, response = result?.tsType ?? t.tsUnknownKeyword(), params = options.params ?? recordOf(t.tsUnknownKeyword()), referenced = /* @__PURE__ */ new Set();
+	collectReferences(response, referenced), collectReferences(params, referenced);
+	let body = [];
+	if (result) {
+		let aliases = referencedSchemaTypes(result.schemaTypes, referenced), renames = renamesFor(aliases.map(({ id }) => id.name));
+		renames.size > 0 && (response = renamed(response, renames), params = renamed(params, renames), aliases = aliases.map(({ id, tsType }) => ({
+			id: t.identifier(renames.get(id.name) ?? id.name),
+			tsType: renamed(tsType, renames)
+		}))), referenced.has("internalGroqTypeReferenceTo") && body.push(internalReferenceSymbol()), referenced.has("ArrayOf") && body.push(arrayOf());
+		for (let { id, tsType } of aliases) body.push(t.tsTypeAliasDeclaration(id, null, tsType));
+	}
+	body.push(documented(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(QUERY_RESPONSE), null, response)), " The result of this query, as `client.fetch` resolves it. "), documented(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(QUERY_PARAMS), null, params)), " The values for the `$` placeholders in this query. "), queryDeclaration(query), t.exportDefaultDeclaration(t.identifier("query")));
+	let comments = [
+		` Source: ${normalizePrintablePath(root, filename)}`,
+		...schemaPath ? [` Schema: ${normalizePrintablePath(root, schemaPath)}`] : [],
+		...notes.flatMap((note) => note.split("\n").map((line) => ` ${line}`))
+	];
+	return t.addComments(body[0], "leading", comments.map((value) => ({
+		type: "CommentLine",
+		value
+	}))), {
+		ast: t.program(body),
+		code: body.map((statement) => generateCode(statement)).join("")
+	};
+}
+/** `{name: type}` for the inferred params, or `Record<string, never>` for a query without any. */
+function paramsType(params) {
+	return params.size === 0 ? recordOf(t.tsNeverKeyword()) : t.tsTypeLiteral([...params].map(([name, type]) => t.tsPropertySignature(isIdentifierName(name) ? t.identifier(name) : t.stringLiteral(name), t.tsTypeAnnotation(type))));
+}
+/**
+* The default export's declaration: the query's literal type intersected with an object of two
+* optional, readonly phantom properties, `__groqResult` and `__groqParams`. The properties never
+* exist at runtime, and because they are optional the value is still assignable to `string` and
+* to its own literal.
+*/
+function queryDeclaration(query) {
+	let brand = t.tsTypeLiteral([phantomProperty("__groqResult", QUERY_RESPONSE), phantomProperty("__groqParams", QUERY_PARAMS)]), id = t.identifier("query");
+	id.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([t.tsLiteralType(t.stringLiteral(query)), brand]));
+	let declaration = t.variableDeclaration("const", [t.variableDeclarator(id)]);
+	return declaration.declare = !0, declaration;
+}
+function phantomProperty(name, type) {
+	let property = t.tsPropertySignature(t.identifier(name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(type))));
+	return property.optional = !0, property.readonly = !0, property;
+}
+function recordOf(value) {
+	return t.tsTypeReference(t.identifier("Record"), t.tsTypeParameterInstantiation([t.tsStringKeyword(), value]));
+}
+function documented(node, comment) {
+	return t.addComment(node, "leading", `*${comment}`, !1);
+}
+/** `declare const internalGroqTypeReferenceTo: unique symbol`, as `sanity.types.ts` declares it. */
+function internalReferenceSymbol() {
+	let id = t.identifier(INTERNAL_REFERENCE_SYMBOL);
+	id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeOperator(t.tsSymbolKeyword(), "unique"));
+	let declaration = t.variableDeclaration("const", [t.variableDeclarator(id)]);
+	return declaration.declare = !0, declaration;
+}
+/** `type ArrayOf<T> = Array<T & {_key: string}>`, as `sanity.types.ts` declares it. */
+function arrayOf() {
+	return t.tsTypeAliasDeclaration(t.identifier(ARRAY_OF), t.tsTypeParameterDeclaration([t.tsTypeParameter(null, null, "T")]), t.tsTypeReference(t.identifier("Array"), t.tsTypeParameterInstantiation([t.tsIntersectionType([t.tsTypeReference(t.identifier("T")), t.tsTypeLiteral([t.tsPropertySignature(t.identifier("_key"), t.tsTypeAnnotation(t.tsStringKeyword()))])])])));
+}
+/**
+* The schema aliases `referenced` names, and the ones they name in turn, in schema order. Every
+* name found on the way is added to `referenced`.
+*/
+function referencedSchemaTypes(schemaTypes, referenced) {
+	let byName = new Map([...schemaTypes].map((schemaType) => [schemaType.id.name, schemaType])), included = /* @__PURE__ */ new Set(), queue = [...referenced];
+	for (let name = queue.shift(); name !== void 0; name = queue.shift()) {
+		let schemaType = byName.get(name);
+		if (!schemaType || included.has(name)) continue;
+		included.add(name);
+		let inner = /* @__PURE__ */ new Set();
+		collectReferences(schemaType.tsType, inner);
+		for (let innerName of inner) referenced.add(innerName), queue.push(innerName);
+	}
+	return [...byName.values()].filter(({ id }) => included.has(id.name));
+}
+/** New names for the aliases that collide with the module's own exports. */
+function renamesFor(aliasNames) {
+	let renames = /* @__PURE__ */ new Map(), taken = /* @__PURE__ */ new Set([...MODULE_NAMES, ...aliasNames]);
+	for (let name of aliasNames) {
+		if (!MODULE_NAMES.has(name)) continue;
+		let id = getUniqueIdentifierForName(name, taken);
+		taken.add(id.name), renames.set(name, id.name);
+	}
+	return renames;
+}
+/** A copy of `node` with the identifiers in `renames` renamed. The original is shared and kept. */
+function renamed(node, renames) {
+	let copy = t.cloneNode(node, !0);
+	return visitIdentifiers(copy, (identifier) => {
+		identifier.name = renames.get(identifier.name) ?? identifier.name;
+	}), copy;
+}
+/**
+* Adds the identifiers a type mentions: the names of the types it refers to, and the computed
+* keys of its properties, which name a symbol. Plain property names are not references.
+*/
+function collectReferences(node, into) {
+	visitIdentifiers(node, (identifier) => into.add(identifier.name));
+}
+function visitIdentifiers(node, visit) {
+	if (t.isIdentifier(node)) visit(node);
+	else for (let key of t.VISITOR_KEYS[node.type] ?? []) {
+		if (key === "key" && t.isTSPropertySignature(node) && !node.computed) continue;
+		let child = node[key];
+		for (let item of Array.isArray(child) ? child : [child]) item && visitIdentifiers(item, visit);
+	}
+}
+/** @beta */
+const JsonRpcErrorCode = {
+	InternalError: -32603,
+	InvalidParams: -32602,
+	InvalidRequest: -32600,
+	MethodNotFound: -32601,
+	ParseError: -32700
+};
+/**
+* An error a request handler throws to answer with a specific JSON-RPC error code. Any other
+* error is answered as an internal error with its message.
+* @beta
+*/
+var JsonRpcError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message), this.name = "JsonRpcError", this.code = code;
+	}
+};
+/**
+* Serves JSON-RPC 2.0 over a pair of streams, framed with `Content-Length` headers the way the
+* LSP base protocol and TypeScript's content mapper host do. Requests are answered one at a
+* time, in order. Resolves once `input` ends and the last answer is written, and rejects if
+* `input` errors.
+* @beta
+*/
+async function serveJsonRpc({ handle, input, output }) {
+	let buffer = Buffer.alloc(0);
+	for await (let chunk of input) {
+		buffer = Buffer.concat([buffer, typeof chunk == "string" ? Buffer.from(chunk) : chunk]);
+		for (let frame = readFrame(buffer); frame; frame = readFrame(buffer)) buffer = buffer.subarray(frame.consumed), await respond(frame.body, handle, output);
+	}
+}
+/** The next complete frame in `buffer`, or `undefined` while it is still arriving. */
+function readFrame(buffer) {
+	let headerEnd = buffer.indexOf("\r\n\r\n");
+	if (headerEnd === -1) return;
+	let length = Number(/content-length:\s*(\d+)/i.exec(buffer.toString("utf8", 0, headerEnd))?.[1]);
+	if (!Number.isSafeInteger(length)) return {
+		body: void 0,
+		consumed: headerEnd + 4
+	};
+	let bodyStart = headerEnd + 4;
+	if (!(buffer.length < bodyStart + length)) return {
+		body: buffer.subarray(bodyStart, bodyStart + length),
+		consumed: bodyStart + length
+	};
+}
+async function respond(body, handle, output) {
+	if (body === void 0) {
+		writeError(output, null, JsonRpcErrorCode.InvalidRequest, "Invalid Request");
+		return;
+	}
+	let message;
+	try {
+		message = JSON.parse(body.toString("utf8"));
+	} catch {
+		writeError(output, null, JsonRpcErrorCode.ParseError, "Parse error");
+		return;
+	}
+	if (!isRequest(message)) writeError(output, idOf(message), JsonRpcErrorCode.InvalidRequest, "Invalid Request");
+	else try {
+		let result = await handle(message);
+		message.id !== void 0 && write(output, {
+			id: message.id,
+			jsonrpc: "2.0",
+			result
+		});
+	} catch (error) {
+		if (message.id === void 0) return;
+		let code = error instanceof JsonRpcError ? error.code : JsonRpcErrorCode.InternalError, text = error instanceof Error ? error.message : "Internal error";
+		writeError(output, message.id, code, text);
+	}
+}
+function isRequest(value) {
+	if (typeof value != "object" || !value || Array.isArray(value)) return !1;
+	let record = value;
+	return record.jsonrpc === "2.0" && typeof record.method == "string" && (!("id" in record) || isId(record.id));
+}
+function idOf(value) {
+	return typeof value != "object" || !value || !("id" in value) ? null : isId(value.id) ? value.id : null;
+}
+function isId(value) {
+	return value === null || typeof value == "string" || typeof value == "number";
+}
+function writeError(output, id, code, message) {
+	write(output, {
+		error: {
+			code,
+			message
+		},
+		id,
+		jsonrpc: "2.0"
+	});
+}
+function write(output, message) {
+	let body = Buffer.from(JSON.stringify(message), "utf8");
+	output.write(Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`), body]));
+}
+const pathString = v.pipe(v.string(), v.nonEmpty("Must not be empty")), schemaEntry = v.strictObject({
+	include: v.union([pathString, v.pipe(v.array(pathString), v.minLength(1, "List a folder"))]),
+	schema: pathString
+});
+/**
+* Validates the options object of a `contentMappers` entry. What is well-formed is kept, so one
+* bad entry does not stop the others from typing their files, and each problem is reported
+* with its path into the object.
+*/
+function parseGroqFilesOptions(input) {
+	let issues = [], options = {};
+	if (input !== void 0 && !isRecord(input)) return issues.push({
+		message: "The options must be an object.",
+		path: []
+	}), {
+		issues,
+		options
+	};
+	let record = input ?? {};
+	for (let key of Object.keys(record)) key !== "schema" && key !== "schemas" && issues.push({
+		message: `Unknown option "${key}". The options are "schema" and "schemas".`,
+		path: [key]
+	});
+	if (record.schema !== void 0 && (typeof record.schema == "string" && record.schema.length > 0 ? options.schema = record.schema : issues.push({
+		message: "\"schema\" must be the path of a schema file.",
+		path: ["schema"]
+	})), record.schemas !== void 0) {
+		if (Array.isArray(record.schemas)) {
+			options.schemas = [];
+			for (let [index, item] of record.schemas.entries()) {
+				let parsed = v.safeParse(schemaEntry, item);
+				if (parsed.success) options.schemas.push(parsed.output);
+				else for (let issue of parsed.issues) issues.push({
+					message: issue.message,
+					path: [
+						"schemas",
+						index,
+						...(issue.path ?? []).map((item) => item.key)
+					]
+				});
+			}
+		} else issues.push({
+			message: "\"schemas\" must be a list of {include, schema} entries.",
+			path: ["schemas"]
+		});
+	}
+	return options.schema === void 0 && !options.schemas?.length && issues.push({
+		message: "Set \"schema\" to the file \"sanity schema extract\" writes, or \"schemas\" to one such file per folder.",
+		path: []
+	}), {
+		issues,
+		options
+	};
+}
+/**
+* Resolves `options` against `root`, the tsconfig's directory, and reads every schema it names.
+* A schema that cannot be read is kept with its `error`, which the mapper reports on every
+* `.groq` file that needed it, so the imports keep resolving while the schema is fixed.
+*
+* Without a `root`, as for a TypeScript project that has no tsconfig, only absolute paths can
+* be resolved; a relative one is an error on the schema it was meant to locate.
+*/
+async function resolveGroqFiles({ options, root }) {
+	let locate = (path) => root === void 0 ? isAbsolute(path) ? path : void 0 : resolve(root, path), load = async (path) => {
+		let located = locate(path);
+		return located === void 0 ? { error: `Without a tsconfig.json to resolve it against, "${path}" must be an absolute path.` } : loadSchema(located);
+	}, fallback = options.schema === void 0 ? void 0 : await load(options.schema), scopes = await Promise.all((options.schemas ?? []).map(async (entry) => {
+		let folders = (Array.isArray(entry.include) ? entry.include : [entry.include]).flatMap((folder) => {
+			let located = locate(folder);
+			return located === void 0 ? [] : [normalizePath(located)];
+		});
+		return Object.assign(await load(entry.schema), { folders });
+	})), watchedFiles = [fallback, ...scopes].flatMap((located) => located?.schemaPath === void 0 ? [] : [located.schemaPath]);
+	return {
+		fallback,
+		root,
+		scopes,
+		watchedFiles: [...new Set(watchedFiles)]
+	};
+}
+/**
+* The schema for a `.groq` file: that of the `schemas` entry whose longest folder contains it,
+* else `schema`, else an error saying neither covers the file.
+*/
+function schemaFor(resolved, file) {
+	let path = normalizePath(file), best, depth = -1;
+	for (let scope of resolved.scopes) for (let folder of scope.folders) folder.length > depth && path.startsWith(`${folder}${sep}`) && (best = scope, depth = folder.length);
+	return best || (resolved.fallback ? resolved.fallback : { error: resolved.scopes.length > 0 ? "This file is outside every \"schemas\" folder, and no \"schema\" is set for the rest." : "No schema is configured. Set the content mapper option \"schema\" to the file \"sanity schema extract\" writes." });
+}
+async function loadSchema(schemaPath) {
+	let bytes;
+	try {
+		bytes = await readFile(schemaPath);
+	} catch (error) {
+		return {
+			error: typeof error == "object" && error && "code" in error && error.code === "ENOENT" ? `No schema file at ${schemaPath}. Run "sanity schema extract" to create it.` : `Could not read the schema at ${schemaPath}: ${getMessage(error)}`,
+			schemaPath
+		};
+	}
+	let schema;
+	try {
+		schema = JSON.parse(bytes.toString("utf8"));
+	} catch (error) {
+		return {
+			bytes,
+			error: `Could not parse the schema at ${schemaPath}: ${getMessage(error)}`,
+			schemaPath
+		};
+	}
+	return Array.isArray(schema) ? {
+		bytes,
+		schema,
+		schemaPath
+	} : {
+		bytes,
+		error: `${schemaPath} is not the array "sanity schema extract" writes.`,
+		schemaPath
+	};
+}
+/** Resolved, without a trailing separator, and case-folded where the file system is. */
+function normalizePath(path) {
+	let resolved = resolve(path);
+	return process.platform === "win32" || process.platform === "darwin" ? resolved.toLowerCase() : resolved;
+}
+function isRecord(value) {
+	return typeof value == "object" && !!value && !Array.isArray(value);
+}
+/**
+* The source TypeScript shows for the mapper's diagnostics, as in `error groq2`.
+* @beta
+*/
+const DIAGNOSTIC_SOURCE = "groq", initializeParams = v.looseObject({
+	positionEncodings: v.array(v.string()),
+	protocolVersion: v.optional(v.number())
+}), openProjectParams = v.looseObject({
+	configFileName: v.string(),
+	options: v.optional(v.unknown()),
+	projectHandle: v.string()
+}), transformParams = v.looseObject({
+	content: v.string(),
+	fileName: v.string(),
+	projectHandle: v.string()
+}), closeProjectParams = v.looseObject({ projectHandle: v.string() });
+/**
+* A TypeScript 7.1 content mapper that types `.groq` files from their live content, so
+* `import query from './posts.groq'` is typed with nothing generated to disk. TypeScript
+* starts it from the `typescript.contentMapper` field of this package's `package.json` when a
+* `tsconfig.json` registers it:
+*
+* ```jsonc
+* {
+*   "contentMappers": [
+*     {"package": "@sanity-labs/groq-content-mapper", "extensions": [".groq"], "options": {"schema": "./schema.json"}}
+*   ]
+* }
+* ```
+*
+* The tsconfig is the only place the mapper is configured. `options` is a `GroqFilesOptions`
+* object: `schema`, the file `sanity schema extract` writes, or `schemas`, one such file per
+* folder for a codebase that queries more than one project or dataset. The mapper declares
+* `dynamicConfig`, so every schema is watched and the project is reopened when one changes.
+*
+* One instance serves any number of projects, each under the handle TypeScript assigns it.
+* @beta
+*/
+var ContentMapper = class ContentMapper {
+	projects = /* @__PURE__ */ new Map();
+	static initialize({ positionEncodings, protocolVersion }) {
+		if (protocolVersion !== void 0 && protocolVersion !== 1) throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `This content mapper speaks protocol version 1, not ${protocolVersion}.`);
+		if (!positionEncodings.includes("utf-16")) throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "This content mapper reports positions in utf-16, which the host does not accept.");
+		return {
+			diagnosticSource: DIAGNOSTIC_SOURCE,
+			positionEncoding: "utf-16",
+			protocolVersion: 1
+		};
+	}
+	/**
+	* Answers one request of the protocol: `initialize`, `openProject`, `transform` or
+	* `closeProject`. Throws a `JsonRpcError` for a request the mapper cannot answer.
+	*/
+	async handle(method, params) {
+		switch (method) {
+			case "closeProject": return this.projects.delete(parse$1(closeProjectParams, params, method).projectHandle), {};
+			case "initialize": return ContentMapper.initialize(parse$1(initializeParams, params, method));
+			case "openProject": return this.openProject(parse$1(openProjectParams, params, method));
+			case "transform": return this.transform(parse$1(transformParams, params, method));
+			default: throw new JsonRpcError(JsonRpcErrorCode.MethodNotFound, `Unknown method "${method}".`);
+		}
+	}
+	/** Serves the protocol over the streams until `input` ends. */
+	serve({ input, output }) {
+		return serveJsonRpc({
+			handle: (request) => this.handle(request.method, request.params),
+			input,
+			output
+		});
+	}
+	async openProject({ configFileName, options, projectHandle }) {
+		let root = configFileName === "" ? void 0 : dirname(configFileName), parsed = parseGroqFilesOptions(options), optionDiagnostics = parsed.issues.map(({ message, path }) => ({
+			code: 1,
+			messageText: message,
+			path
+		})), resolved = await resolveGroqFiles({
+			options: parsed.options,
+			root
+		});
+		this.projects.set(projectHandle, { resolved });
+		let identity = createHash("sha256");
+		for (let located of [resolved.fallback, ...resolved.scopes]) identity.update(`${located?.schemaPath ?? ""}\0`), identity.update(located?.bytes ?? "missing"), identity.update("\0");
+		return {
+			configIdentity: identity.digest("hex"),
+			...optionDiagnostics.length > 0 ? { optionDiagnostics } : {},
+			watchedFiles: resolved.watchedFiles
+		};
+	}
+	transform({ content, fileName, projectHandle }) {
+		let project = this.projects.get(projectHandle);
+		if (!project) throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `Unknown project "${projectHandle}".`);
+		let { resolved } = project, root = resolved.root ?? dirname(fileName), located = schemaFor(resolved, fileName);
+		if (!located.schema) {
+			let messageText = located.error ?? "No schema is configured.", { code } = renderGroqModule({
+				filename: fileName,
+				notes: [messageText],
+				query: content,
+				root,
+				schemaPath: located.schemaPath
+			});
+			return {
+				diagnostics: [{
+					code: GroqFileDiagnosticCode.SchemaUnavailable,
+					length: Math.min(1, content.length),
+					messageText,
+					start: 0
+				}],
+				extension: ".mts",
+				text: code
+			};
+		}
+		let { code, diagnostics } = generateGroqModule({
+			content,
+			filename: fileName,
+			root,
+			schema: located.schema,
+			schemaPath: located.schemaPath
+		});
+		return {
+			...diagnostics.length > 0 ? { diagnostics } : {},
+			extension: ".mts",
+			text: code
+		};
+	}
+};
+function parse$1(schema, params, method) {
+	let result = v.safeParse(schema, params);
+	if (result.success) return result.output;
+	let issues = result.issues.map((issue) => `${v.getDotPath(issue) ?? "params"}: ${issue.message}`);
+	throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, `Invalid params for ${method}: ${issues.join("; ")}`);
+}
+export { serveJsonRpc as a, JsonRpcErrorCode as i, DIAGNOSTIC_SOURCE as n, GroqFileDiagnosticCode as o, JsonRpcError as r, generateGroqModule as s, ContentMapper as t };
+
+//# sourceMappingURL=contentMapper-BMNwbuMF.js.map