@jterrazz/test 16.1.0 → 17.0.0

package/dist/shared-yaml-document.js

@@ -0,0 +1,119 @@
+import { LineCounter, Scalar, Scalar as Scalar$1, isMap, isNode, isNode as isNode$1, isPair, isScalar, isSeq, parseDocument, visit } from "yaml";
+//#region lint/kit/project/yaml-document.ts
+function nodePairs(map) {
+	return map.items.filter((pair) => isNode(pair.key) && (pair.value === null || isNode(pair.value)));
+}
+function nodeItems(seq) {
+	return seq.items.filter((item) => isNode(item));
+}
+const KEY_LINE = /^(?<indent> +)(?:(?:- )?[A-Za-z_$'"][^\n]*:|- [[{])/u;
+function detectIndent(text) {
+	let smallest = 0;
+	for (const line of text.split("\n")) {
+		const indent = KEY_LINE.exec(line)?.groups?.indent;
+		if (indent !== void 0 && (smallest === 0 || indent.length < smallest)) smallest = indent.length;
+	}
+	return smallest === 0 ? 2 : smallest;
+}
+const DEEPEST_STATABLE_STEP = 9;
+function stateIndentation(written, ctx) {
+	if (!/^[|>][1-9]/u.test(written)) return written;
+	const step = ctx.indentStep.length;
+	if (step > DEEPEST_STATABLE_STEP) throw new Error(`A block scalar indented by ${step} spaces cannot state its indentation: YAML writes that indicator as a single digit, so ${DEEPEST_STATABLE_STEP} spaces is the deepest step a document may be written with.`);
+	return `${written[0]}${step}${written.slice(2)}`;
+}
+function isScalarTag(tag) {
+	return typeof tag !== "string" && tag.collection === void 0;
+}
+function statingItsIndentation(tag) {
+	const write = tag.stringify;
+	if (write === void 0) return tag;
+	return {
+		...tag,
+		stringify: (item, ctx, onComment, onChompKeep) => stateIndentation(write(item, ctx, onComment, onChompKeep), ctx)
+	};
+}
+function parseYamlSource(text) {
+	const lineCounter = new LineCounter();
+	return {
+		document: parseDocument(text, {
+			customTags: (tags) => tags.map((tag) => isScalarTag(tag) ? statingItsIndentation(tag) : tag),
+			lineCounter
+		}),
+		indent: detectIndent(text),
+		lineAt: (offset) => lineCounter.linePos(offset).line,
+		text
+	};
+}
+function yamlSyntaxErrors(source) {
+	return source.document.errors.map((error) => ({
+		line: source.lineAt(error.pos[0]),
+		message: error.message
+	}));
+}
+function blockScalar(text) {
+	const scalar = new Scalar(text);
+	scalar.type = Scalar.BLOCK_LITERAL;
+	return scalar;
+}
+function lineStart(text, offset) {
+	return text.lastIndexOf("\n", offset - 1) + 1;
+}
+function afterOwner(text, offset) {
+	return text.slice(0, offset).trimEnd().length;
+}
+function indentOf(text, offset) {
+	const line = text.slice(lineStart(text, offset));
+	return line.length - line.trimStart().length;
+}
+function flowCollections(text) {
+	const found = [];
+	const take = (node) => {
+		if (node.flow !== true) return;
+		const { range } = node;
+		if (range === null || range === void 0) return;
+		const [start, end] = range;
+		const from = afterOwner(text, start);
+		found.push({
+			ownerIndent: indentOf(text, from),
+			range: [from, end],
+			text: text.slice(from, end),
+			value: JSON.stringify(node.toJSON())
+		});
+		return visit.SKIP;
+	};
+	visit(parseDocument(text), {
+		Map: (_key, node) => take(node),
+		Seq: (_key, node) => take(node)
+	});
+	return found;
+}
+function restoreUntouchedFlow(rendered, text) {
+	const sources = flowCollections(text);
+	const taken = /* @__PURE__ */ new Set();
+	const splices = [];
+	for (const target of flowCollections(rendered)) {
+		const at = sources.findIndex((candidate, index) => !taken.has(index) && candidate.value === target.value && candidate.ownerIndent === target.ownerIndent);
+		const source = sources[at];
+		if (source === void 0) continue;
+		taken.add(at);
+		splices.push({
+			range: target.range,
+			text: source.text
+		});
+	}
+	let out = rendered;
+	for (const splice of splices.toReversed()) out = out.slice(0, splice.range[0]) + splice.text + out.slice(splice.range[1]);
+	return out;
+}
+/** `lineWidth: 0`: a golden is compared byte for byte, so nothing folds a long line. */
+function renderYamlSource(source) {
+	return restoreUntouchedFlow(source.document.toString({
+		indent: source.indent,
+		lineWidth: 0
+	}), source.text);
+}
+//#endregion
+export { isPair as a, nodeItems as c, renderYamlSource as d, yamlSyntaxErrors as f, isNode$1 as i, nodePairs as l, blockScalar as n, isScalar as o, isMap as r, isSeq as s, Scalar$1 as t, parseYamlSource as u };
+
+//# sourceMappingURL=shared-yaml-document.js.map

package/dist/stubs.d.ts

@@ -0,0 +1,2 @@
+import { C as StubRequest, E as StubResponseValue, S as StreamBody, T as StubResponse, _ as StubInput, a as openai, b as defineStubs, c as SseEvent, d as anthropic, f as TextFilter, g as Stub, i as InterceptScope, l as http, n as Intercept, o as HttpResponseInit, r as InterceptOptions, s as HttpStreamInit, t as intercept, u as HttpStubFilter, v as Stubs, w as StubResponder, x as MatchableRequest, y as defineStub } from "./shared-index.stubs.js";
+export { type HttpResponseInit, type HttpStreamInit, type HttpStubFilter, type Intercept, type InterceptOptions, type InterceptScope, type MatchableRequest, type SseEvent, type StreamBody, type Stub, type StubInput, type StubRequest, type StubResponder, type StubResponse, type StubResponseValue, type Stubs, type TextFilter, anthropic, defineStub, defineStubs, http, intercept, openai };