@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

package/dist/node_modules/langium/lib/utils/stream.js

@@ -0,0 +1,327 @@
+var StreamImpl = class e {
+	constructor(e, r) {
+		this.startFn = e, this.nextFn = r;
+	}
+	iterator() {
+		let e = {
+			state: this.startFn(),
+			next: () => this.nextFn(e.state),
+			[Symbol.iterator]: () => e
+		};
+		return e;
+	}
+	[Symbol.iterator]() {
+		return this.iterator();
+	}
+	isEmpty() {
+		return !!this.iterator().next().done;
+	}
+	count() {
+		let e = this.iterator(), r = 0, i = e.next();
+		for (; !i.done;) r++, i = e.next();
+		return r;
+	}
+	toArray() {
+		let e = [], r = this.iterator(), i;
+		do
+			i = r.next(), i.value !== void 0 && e.push(i.value);
+		while (!i.done);
+		return e;
+	}
+	toSet() {
+		return new Set(this);
+	}
+	toMap(e, r) {
+		let i = this.map((i) => [e ? e(i) : i, r ? r(i) : i]);
+		return new Map(i);
+	}
+	toString() {
+		return this.join();
+	}
+	concat(r) {
+		return new e(() => ({
+			first: this.startFn(),
+			firstDone: !1,
+			iterator: r[Symbol.iterator]()
+		}), (e) => {
+			let r;
+			if (!e.firstDone) {
+				do
+					if (r = this.nextFn(e.first), !r.done) return r;
+				while (!r.done);
+				e.firstDone = !0;
+			}
+			do
+				if (r = e.iterator.next(), !r.done) return r;
+			while (!r.done);
+			return DONE_RESULT;
+		});
+	}
+	join(e = ",") {
+		let i = this.iterator(), a = "", o, s = !1;
+		do
+			o = i.next(), o.done || (s && (a += e), a += toString(o.value)), s = !0;
+		while (!o.done);
+		return a;
+	}
+	indexOf(e, r = 0) {
+		let i = this.iterator(), a = 0, o = i.next();
+		for (; !o.done;) {
+			if (a >= r && o.value === e) return a;
+			o = i.next(), a++;
+		}
+		return -1;
+	}
+	every(e) {
+		let r = this.iterator(), i = r.next();
+		for (; !i.done;) {
+			if (!e(i.value)) return !1;
+			i = r.next();
+		}
+		return !0;
+	}
+	some(e) {
+		let r = this.iterator(), i = r.next();
+		for (; !i.done;) {
+			if (e(i.value)) return !0;
+			i = r.next();
+		}
+		return !1;
+	}
+	forEach(e) {
+		let r = this.iterator(), i = 0, a = r.next();
+		for (; !a.done;) e(a.value, i), a = r.next(), i++;
+	}
+	map(r) {
+		return new e(this.startFn, (e) => {
+			let { done: i, value: a } = this.nextFn(e);
+			return i ? DONE_RESULT : {
+				done: !1,
+				value: r(a)
+			};
+		});
+	}
+	filter(r) {
+		return new e(this.startFn, (e) => {
+			let i;
+			do
+				if (i = this.nextFn(e), !i.done && r(i.value)) return i;
+			while (!i.done);
+			return DONE_RESULT;
+		});
+	}
+	nonNullable() {
+		return this.filter((e) => e != null);
+	}
+	reduce(e, r) {
+		let i = this.iterator(), a = r, o = i.next();
+		for (; !o.done;) a = a === void 0 ? o.value : e(a, o.value), o = i.next();
+		return a;
+	}
+	reduceRight(e, r) {
+		return this.recursiveReduce(this.iterator(), e, r);
+	}
+	recursiveReduce(e, r, i) {
+		let a = e.next();
+		if (a.done) return i;
+		let o = this.recursiveReduce(e, r, i);
+		return o === void 0 ? a.value : r(o, a.value);
+	}
+	find(e) {
+		let r = this.iterator(), i = r.next();
+		for (; !i.done;) {
+			if (e(i.value)) return i.value;
+			i = r.next();
+		}
+	}
+	findIndex(e) {
+		let r = this.iterator(), i = 0, a = r.next();
+		for (; !a.done;) {
+			if (e(a.value)) return i;
+			a = r.next(), i++;
+		}
+		return -1;
+	}
+	includes(e) {
+		let r = this.iterator(), i = r.next();
+		for (; !i.done;) {
+			if (i.value === e) return !0;
+			i = r.next();
+		}
+		return !1;
+	}
+	flatMap(r) {
+		return new e(() => ({ this: this.startFn() }), (e) => {
+			do {
+				if (e.iterator) {
+					let r = e.iterator.next();
+					if (r.done) e.iterator = void 0;
+					else return r;
+				}
+				let { done: a, value: o } = this.nextFn(e.this);
+				if (!a) {
+					let a = r(o);
+					if (isIterable(a)) e.iterator = a[Symbol.iterator]();
+					else return {
+						done: !1,
+						value: a
+					};
+				}
+			} while (e.iterator);
+			return DONE_RESULT;
+		});
+	}
+	flat(r) {
+		if (r === void 0 && (r = 1), r <= 0) return this;
+		let a = r > 1 ? this.flat(r - 1) : this;
+		return new e(() => ({ this: a.startFn() }), (e) => {
+			do {
+				if (e.iterator) {
+					let r = e.iterator.next();
+					if (r.done) e.iterator = void 0;
+					else return r;
+				}
+				let { done: r, value: o } = a.nextFn(e.this);
+				if (!r) if (isIterable(o)) e.iterator = o[Symbol.iterator]();
+				else return {
+					done: !1,
+					value: o
+				};
+			} while (e.iterator);
+			return DONE_RESULT;
+		});
+	}
+	head() {
+		let e = this.iterator().next();
+		if (!e.done) return e.value;
+	}
+	tail(r = 1) {
+		return new e(() => {
+			let e = this.startFn();
+			for (let i = 0; i < r; i++) if (this.nextFn(e).done) return e;
+			return e;
+		}, this.nextFn);
+	}
+	limit(r) {
+		return new e(() => ({
+			size: 0,
+			state: this.startFn()
+		}), (e) => (e.size++, e.size > r ? DONE_RESULT : this.nextFn(e.state)));
+	}
+	distinct(r) {
+		return new e(() => ({
+			set: /* @__PURE__ */ new Set(),
+			internalState: this.startFn()
+		}), (e) => {
+			let i;
+			do
+				if (i = this.nextFn(e.internalState), !i.done) {
+					let a = r ? r(i.value) : i.value;
+					if (!e.set.has(a)) return e.set.add(a), i;
+				}
+			while (!i.done);
+			return DONE_RESULT;
+		});
+	}
+	exclude(e, r) {
+		let i = /* @__PURE__ */ new Set();
+		for (let a of e) {
+			let e = r ? r(a) : a;
+			i.add(e);
+		}
+		return this.filter((e) => {
+			let a = r ? r(e) : e;
+			return !i.has(a);
+		});
+	}
+};
+function toString(e) {
+	return typeof e == "string" ? e : e === void 0 ? "undefined" : typeof e.toString == "function" ? e.toString() : Object.prototype.toString.call(e);
+}
+function isIterable(e) {
+	return !!e && typeof e[Symbol.iterator] == "function";
+}
+const EMPTY_STREAM = new StreamImpl(() => void 0, () => DONE_RESULT), DONE_RESULT = Object.freeze({
+	done: !0,
+	value: void 0
+});
+function stream(...r) {
+	if (r.length === 1) {
+		let a = r[0];
+		if (a instanceof StreamImpl) return a;
+		if (isIterable(a)) return new StreamImpl(() => a[Symbol.iterator](), (e) => e.next());
+		if (typeof a.length == "number") return new StreamImpl(() => ({ index: 0 }), (e) => e.index < a.length ? {
+			done: !1,
+			value: a[e.index++]
+		} : DONE_RESULT);
+	}
+	return r.length > 1 ? new StreamImpl(() => ({
+		collIndex: 0,
+		arrIndex: 0
+	}), (e) => {
+		do {
+			if (e.iterator) {
+				let r = e.iterator.next();
+				if (!r.done) return r;
+				e.iterator = void 0;
+			}
+			if (e.array) {
+				if (e.arrIndex < e.array.length) return {
+					done: !1,
+					value: e.array[e.arrIndex++]
+				};
+				e.array = void 0, e.arrIndex = 0;
+			}
+			if (e.collIndex < r.length) {
+				let a = r[e.collIndex++];
+				isIterable(a) ? e.iterator = a[Symbol.iterator]() : a && typeof a.length == "number" && (e.array = a);
+			}
+		} while (e.iterator || e.array || e.collIndex < r.length);
+		return DONE_RESULT;
+	}) : EMPTY_STREAM;
+}
+var TreeStreamImpl = class extends StreamImpl {
+	constructor(e, r, i) {
+		super(() => ({
+			iterators: i?.includeRoot ? [[e][Symbol.iterator]()] : [r(e)[Symbol.iterator]()],
+			pruned: !1
+		}), (e) => {
+			for (e.pruned &&= (e.iterators.pop(), !1); e.iterators.length > 0;) {
+				let i = e.iterators[e.iterators.length - 1].next();
+				if (i.done) e.iterators.pop();
+				else return e.iterators.push(r(i.value)[Symbol.iterator]()), i;
+			}
+			return DONE_RESULT;
+		});
+	}
+	iterator() {
+		let e = {
+			state: this.startFn(),
+			next: () => this.nextFn(e.state),
+			prune: () => {
+				e.state.pruned = !0;
+			},
+			[Symbol.iterator]: () => e
+		};
+		return e;
+	}
+}, Reduction;
+(function(e) {
+	function r(e) {
+		return e.reduce((e, r) => e + r, 0);
+	}
+	e.sum = r;
+	function i(e) {
+		return e.reduce((e, r) => e * r, 0);
+	}
+	e.product = i;
+	function a(e) {
+		return e.reduce((e, r) => Math.min(e, r));
+	}
+	e.min = a;
+	function o(e) {
+		return e.reduce((e, r) => Math.max(e, r));
+	}
+	e.max = o;
+})(Reduction ||= {});
+export { DONE_RESULT, EMPTY_STREAM, Reduction, StreamImpl, TreeStreamImpl, stream };

package/dist/node_modules/langium/lib/utils/uri-utils.js

@@ -0,0 +1,107 @@
+import { URI, Utils } from "../../../vscode-uri/lib/esm/index.js";
+var UriUtils;
+(function(n) {
+	n.basename = Utils.basename, n.dirname = Utils.dirname, n.extname = Utils.extname, n.joinPath = Utils.joinPath, n.resolvePath = Utils.resolvePath;
+	let r = typeof process == "object" && process?.platform === "win32";
+	function i(e, t) {
+		return e?.toString() === t?.toString();
+	}
+	n.equals = i;
+	function a(t, n) {
+		let i = typeof t == "string" ? URI.parse(t).path : t.path, a = typeof n == "string" ? URI.parse(n).path : n.path, o = i.split("/").filter((e) => e.length > 0), s = a.split("/").filter((e) => e.length > 0);
+		if (r) {
+			let e = /^[A-Z]:$/;
+			if (o[0] && e.test(o[0]) && (o[0] = o[0].toLowerCase()), s[0] && e.test(s[0]) && (s[0] = s[0].toLowerCase()), o[0] !== s[0]) return a.substring(1);
+		}
+		let c = 0;
+		for (; c < o.length && o[c] === s[c]; c++);
+		return "../".repeat(o.length - c) + s.slice(c).join("/");
+	}
+	n.relative = a;
+	function o(t) {
+		return URI.parse(t.toString()).toString();
+	}
+	n.normalize = o;
+	function s(e, t) {
+		let n = typeof e == "string" ? e : e.path, r = typeof t == "string" ? t : t.path;
+		return r.charAt(r.length - 1) === "/" && (r = r.slice(0, -1)), n.charAt(n.length - 1) === "/" && (n = n.slice(0, -1)), r === n ? !0 : r.length < n.length || r.charAt(n.length) !== "/" ? !1 : r.startsWith(n);
+	}
+	n.contains = s;
+})(UriUtils ||= {});
+var UriTrie = class {
+	constructor() {
+		this.root = {
+			name: "",
+			children: /* @__PURE__ */ new Map()
+		};
+	}
+	normalizeUri(e) {
+		return UriUtils.normalize(e);
+	}
+	clear() {
+		this.root.children.clear();
+	}
+	insert(e, t) {
+		let n = this.getNode(this.normalizeUri(e), !0);
+		n.element = t;
+	}
+	delete(e) {
+		let t = this.getNode(this.normalizeUri(e), !1);
+		t?.parent && t.parent.children.delete(t.name);
+	}
+	has(e) {
+		return this.getNode(this.normalizeUri(e), !1)?.element !== void 0;
+	}
+	hasNode(e) {
+		return this.getNode(this.normalizeUri(e), !1) !== void 0;
+	}
+	find(e) {
+		return this.getNode(this.normalizeUri(e), !1)?.element;
+	}
+	findNode(t) {
+		let r = this.normalizeUri(t), i = this.getNode(r, !1);
+		if (i) return {
+			name: i.name,
+			uri: UriUtils.joinPath(URI.parse(r), i.name).toString(),
+			element: i.element
+		};
+	}
+	findChildren(t) {
+		let r = this.normalizeUri(t), i = this.getNode(r, !1);
+		return i ? Array.from(i.children.values()).map((t) => ({
+			name: t.name,
+			uri: UriUtils.joinPath(URI.parse(r), t.name).toString(),
+			element: t.element
+		})) : [];
+	}
+	all() {
+		return this.collectValues(this.root);
+	}
+	findAll(e) {
+		let t = this.getNode(UriUtils.normalize(e), !1);
+		return t ? this.collectValues(t) : [];
+	}
+	getNode(e, t) {
+		let n = e.split("/");
+		e.charAt(e.length - 1) === "/" && n.pop();
+		let r = this.root;
+		for (let e of n) {
+			let n = r.children.get(e);
+			if (!n) if (t) n = {
+				name: e,
+				children: /* @__PURE__ */ new Map(),
+				parent: r
+			}, r.children.set(e, n);
+			else return;
+			r = n;
+		}
+		return r;
+	}
+	collectValues(e) {
+		let t = [];
+		e.element && t.push(e.element);
+		for (let n of e.children.values()) t.push(...this.collectValues(n));
+		return t;
+	}
+};
+export { UriTrie, UriUtils };

package/dist/node_modules/langium/lib/validation/document-validator.js

@@ -0,0 +1,210 @@
+import { streamAst } from "../utils/ast-utils.js";
+import { tokenToRange } from "../utils/cst-utils.js";
+import { findNodeForKeyword, findNodeForProperty } from "../utils/grammar-utils.js";
+import { cancellation_exports } from "../utils/cancellation.js";
+import { interruptAndCheck, isOperationCancelled } from "../utils/promise-utils.js";
+import { diagnosticData } from "./validation-registry.js";
+const VALIDATE_EACH_NODE = Object.freeze({
+	validateNode: !0,
+	validateChildren: !0
+});
+var DefaultDocumentValidator = class {
+	constructor(e) {
+		this.validationRegistry = e.validation.ValidationRegistry, this.metadata = e.LanguageMetaData, this.profiler = e.shared.profilers.LangiumProfiler, this.languageId = e.LanguageMetaData.languageId;
+	}
+	async validateDocument(e, s = {}, c = cancellation_exports.CancellationToken.None) {
+		let l = e.parseResult, p = [];
+		if (await interruptAndCheck(c), (!s.categories || s.categories.includes("built-in")) && (this.processLexingErrors(l, p, s), s.stopAfterLexingErrors && p.some((e) => e.data?.code === DocumentValidator.LexingError) || (this.processParsingErrors(l, p, s), s.stopAfterParsingErrors && p.some((e) => e.data?.code === DocumentValidator.ParsingError)) || (this.processLinkingErrors(e, p, s), s.stopAfterLinkingErrors && p.some((e) => e.data?.code === DocumentValidator.LinkingError)))) return p;
+		try {
+			p.push(...await this.validateAst(l.value, s, c));
+		} catch (e) {
+			if (isOperationCancelled(e)) throw e;
+			console.error("An error occurred during validation:", e);
+		}
+		return await interruptAndCheck(c), p;
+	}
+	processLexingErrors(e, s, c) {
+		let l = [...e.lexerErrors, ...e.lexerReport?.diagnostics ?? []];
+		for (let e of l) {
+			let c = e.severity ?? "error", l = {
+				severity: toDiagnosticSeverity(c),
+				range: {
+					start: {
+						line: e.line - 1,
+						character: e.column - 1
+					},
+					end: {
+						line: e.line - 1,
+						character: e.column + e.length - 1
+					}
+				},
+				message: e.message,
+				data: toDiagnosticData(c),
+				source: this.getSource()
+			};
+			s.push(l);
+		}
+	}
+	processParsingErrors(e, c, l) {
+		for (let l of e.parserErrors) {
+			let e;
+			if (isNaN(l.token.startOffset)) {
+				if ("previousToken" in l) {
+					let s = l.previousToken;
+					if (isNaN(s.startOffset)) {
+						let s = {
+							line: 0,
+							character: 0
+						};
+						e = {
+							start: s,
+							end: s
+						};
+					} else {
+						let c = {
+							line: s.endLine - 1,
+							character: s.endColumn
+						};
+						e = {
+							start: c,
+							end: c
+						};
+					}
+				}
+			} else e = tokenToRange(l.token);
+			if (e) {
+				let s = {
+					severity: toDiagnosticSeverity("error"),
+					range: e,
+					message: l.message,
+					data: diagnosticData(DocumentValidator.ParsingError),
+					source: this.getSource()
+				};
+				c.push(s);
+			}
+		}
+	}
+	processLinkingErrors(e, s, c) {
+		for (let c of e.references) {
+			let e = c.error;
+			if (e) {
+				let l = {
+					node: e.info.container,
+					range: c.$refNode?.range,
+					property: e.info.property,
+					index: e.info.index,
+					data: {
+						code: DocumentValidator.LinkingError,
+						containerType: e.info.container.$type,
+						property: e.info.property,
+						refText: e.info.reference.$refText
+					}
+				};
+				s.push(this.toDiagnostic("error", e.message, l));
+			}
+		}
+	}
+	async validateAst(e, s, c = cancellation_exports.CancellationToken.None) {
+		let l = [], d = (e, s, c) => {
+			l.push(this.toDiagnostic(e, s, c));
+		};
+		return await this.validateAstBefore(e, s, d, c), await this.validateAstNodes(e, s, d, c), await this.validateAstAfter(e, s, d, c), l;
+	}
+	async validateAstBefore(e, s, c, l = cancellation_exports.CancellationToken.None) {
+		let f = this.validationRegistry.checksBefore;
+		for (let u of f) await interruptAndCheck(l), await u(e, c, s.categories ?? [], l);
+	}
+	async validateAstNodes(s, c, l, f = cancellation_exports.CancellationToken.None) {
+		if (this.profiler?.isActive("validating")) {
+			let u = this.profiler.createTask("validating", this.languageId);
+			u.start();
+			try {
+				let d = streamAst(s).iterator();
+				for (let e of d) {
+					u.startSubTask(e.$type);
+					let s = this.validateSingleNodeOptions(e, c);
+					if (s.validateNode) try {
+						let s = this.validationRegistry.getChecks(e.$type, c.categories);
+						for (let c of s) await c(e, l, f);
+					} finally {
+						u.stopSubTask(e.$type);
+					}
+					s.validateChildren || d.prune();
+				}
+			} finally {
+				u.stop();
+			}
+		} else {
+			let u = streamAst(s).iterator();
+			for (let e of u) {
+				await interruptAndCheck(f);
+				let s = this.validateSingleNodeOptions(e, c);
+				if (s.validateNode) {
+					let s = this.validationRegistry.getChecks(e.$type, c.categories);
+					for (let c of s) await c(e, l, f);
+				}
+				s.validateChildren || u.prune();
+			}
+		}
+	}
+	validateSingleNodeOptions(e, s) {
+		return VALIDATE_EACH_NODE;
+	}
+	async validateAstAfter(e, s, c, l = cancellation_exports.CancellationToken.None) {
+		let f = this.validationRegistry.checksAfter;
+		for (let u of f) await interruptAndCheck(l), await u(e, c, s.categories ?? [], l);
+	}
+	toDiagnostic(e, s, c) {
+		return {
+			message: s,
+			range: getDiagnosticRange(c),
+			severity: toDiagnosticSeverity(e),
+			code: c.code,
+			codeDescription: c.codeDescription,
+			tags: c.tags,
+			relatedInformation: c.relatedInformation,
+			data: c.data,
+			source: this.getSource()
+		};
+	}
+	getSource() {
+		return this.metadata.languageId;
+	}
+};
+function getDiagnosticRange(e) {
+	if (e.range) return e.range;
+	let s;
+	return typeof e.property == "string" ? s = findNodeForProperty(e.node.$cstNode, e.property, e.index) : typeof e.keyword == "string" && (s = findNodeForKeyword(e.node.$cstNode, e.keyword, e.index)), s ??= e.node.$cstNode, s ? s.range : {
+		start: {
+			line: 0,
+			character: 0
+		},
+		end: {
+			line: 0,
+			character: 0
+		}
+	};
+}
+function toDiagnosticSeverity(e) {
+	switch (e) {
+		case "error": return 1;
+		case "warning": return 2;
+		case "info": return 3;
+		case "hint": return 4;
+		default: throw Error("Invalid diagnostic severity: " + e);
+	}
+}
+function toDiagnosticData(e) {
+	switch (e) {
+		case "error": return diagnosticData(DocumentValidator.LexingError);
+		case "warning": return diagnosticData(DocumentValidator.LexingWarning);
+		case "info": return diagnosticData(DocumentValidator.LexingInfo);
+		case "hint": return diagnosticData(DocumentValidator.LexingHint);
+		default: throw Error("Invalid diagnostic severity: " + e);
+	}
+}
+var DocumentValidator;
+(function(e) {
+	e.LexingError = "lexing-error", e.LexingWarning = "lexing-warning", e.LexingInfo = "lexing-info", e.LexingHint = "lexing-hint", e.ParsingError = "parsing-error", e.LinkingError = "linking-error";
+})(DocumentValidator ||= {});
+export { DefaultDocumentValidator, DocumentValidator, VALIDATE_EACH_NODE, getDiagnosticRange, toDiagnosticData, toDiagnosticSeverity };