@webskill/sdk 0.20.0 → 0.22.0

package/dist/diagram-MPIPVDR6-DEFiSo8o.js

@@ -0,0 +1,289 @@
+import { n as parse } from "./mermaid-parser.core-pYR5siSx.js";
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log } from "./src-NkhI3UMl.js";
+import { D as getThemeVariables3, H as setAccDescription, U as setAccTitle, a as clear, b as getConfig, c as configureSvgSize, f as defaultConfig_default, q as setDiagramTitle, v as getAccDescription, w as getDiagramTitle, y as getAccTitle } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+import { i as cleanAndMerge } from "./chunk-ZIGJFQKS-DqEFBuHR.js";
+import { t as selectSvgElement } from "./chunk-6AEJRKK7-JXK89I-O.js";
+import { t as populateCommonDb } from "./chunk-JWPE2WC7-D1rC79GS.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/diagram-MPIPVDR6.mjs
+var defaultOptions = {
+	showLegend: true,
+	ticks: 5,
+	max: null,
+	min: 0,
+	graticule: "circle"
+};
+var MAX_TICKS = 32;
+var defaultRadarData = {
+	axes: [],
+	curves: [],
+	options: defaultOptions
+};
+var data = structuredClone(defaultRadarData);
+var DEFAULT_RADAR_CONFIG = defaultConfig_default.radar;
+var getConfig2 = /* @__PURE__ */ __name(() => {
+	return cleanAndMerge({
+		...DEFAULT_RADAR_CONFIG,
+		...getConfig().radar
+	});
+}, "getConfig");
+var getAxes = /* @__PURE__ */ __name(() => data.axes, "getAxes");
+var getCurves = /* @__PURE__ */ __name(() => data.curves, "getCurves");
+var getOptions = /* @__PURE__ */ __name(() => data.options, "getOptions");
+var setAxes = /* @__PURE__ */ __name((axes) => {
+	data.axes = axes.map((axis) => {
+		return {
+			name: axis.name,
+			label: axis.label ?? axis.name
+		};
+	});
+}, "setAxes");
+var setCurves = /* @__PURE__ */ __name((curves) => {
+	data.curves = curves.map((curve) => {
+		return {
+			name: curve.name,
+			label: curve.label ?? curve.name,
+			entries: computeCurveEntries(curve.entries)
+		};
+	});
+}, "setCurves");
+var computeCurveEntries = /* @__PURE__ */ __name((entries) => {
+	if (entries[0].axis == void 0) return entries.map((entry) => entry.value);
+	const axes = getAxes();
+	if (axes.length === 0) throw new Error("Axes must be populated before curves for reference entries");
+	return axes.map((axis) => {
+		const entry = entries.find((entry2) => entry2.axis?.$refText === axis.name);
+		if (entry === void 0) throw new Error("Missing entry for axis " + axis.label);
+		return entry.value;
+	});
+}, "computeCurveEntries");
+var db = {
+	getAxes,
+	getCurves,
+	getOptions,
+	setAxes,
+	setCurves,
+	setOptions: /* @__PURE__ */ __name((options) => {
+		const optionMap = options.reduce((acc, option) => {
+			acc[option.name] = option;
+			return acc;
+		}, {});
+		data.options = {
+			showLegend: optionMap.showLegend?.value ?? defaultOptions.showLegend,
+			ticks: optionMap.ticks?.value ?? defaultOptions.ticks,
+			max: optionMap.max?.value ?? defaultOptions.max,
+			min: optionMap.min?.value ?? defaultOptions.min,
+			graticule: optionMap.graticule?.value ?? defaultOptions.graticule
+		};
+		if (data.options.ticks > MAX_TICKS) {
+			log.warn(`Radar diagram ticks (${data.options.ticks}) exceeds maximum allowed (${MAX_TICKS}). Using ${MAX_TICKS} instead.`);
+			data.options.ticks = MAX_TICKS;
+		}
+	}, "setOptions"),
+	getConfig: getConfig2,
+	clear: /* @__PURE__ */ __name(() => {
+		clear();
+		data = structuredClone(defaultRadarData);
+	}, "clear"),
+	setAccTitle,
+	getAccTitle,
+	setDiagramTitle,
+	getDiagramTitle,
+	getAccDescription,
+	setAccDescription
+};
+var populate = /* @__PURE__ */ __name((ast) => {
+	populateCommonDb(ast, db);
+	const { axes, curves, options } = ast;
+	db.setAxes(axes);
+	db.setCurves(curves);
+	db.setOptions(options);
+}, "populate");
+var parser = { parse: /* @__PURE__ */ __name(async (input) => {
+	const ast = await parse("radar", input);
+	log.debug(ast);
+	populate(ast);
+}, "parse") };
+var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
+	const db2 = diagram2.db;
+	const axes = db2.getAxes();
+	const curves = db2.getCurves();
+	const options = db2.getOptions();
+	const config = db2.getConfig();
+	const title = db2.getDiagramTitle();
+	const g = drawFrame(selectSvgElement(id), config);
+	const maxValue = options.max ?? Math.max(...curves.map((curve) => Math.max(...curve.entries)));
+	const minValue = options.min;
+	const radius = Math.min(config.width, config.height) / 2;
+	drawGraticule(g, axes, radius, options.ticks, options.graticule);
+	drawAxes(g, axes, radius, config);
+	drawCurves(g, axes, curves, minValue, maxValue, options.graticule, config);
+	drawLegend(g, curves, options.showLegend, config);
+	g.append("text").attr("class", "radarTitle").text(title).attr("x", 0).attr("y", -config.height / 2 - config.marginTop);
+}, "draw");
+var drawFrame = /* @__PURE__ */ __name((svg, config) => {
+	const totalWidth = config.width + config.marginLeft + config.marginRight;
+	const totalHeight = config.height + config.marginTop + config.marginBottom;
+	const center = {
+		x: config.marginLeft + config.width / 2,
+		y: config.marginTop + config.height / 2
+	};
+	configureSvgSize(svg, totalHeight, totalWidth, config.useMaxWidth ?? true);
+	svg.attr("viewBox", `0 0 ${totalWidth} ${totalHeight}`).attr("overflow", "visible");
+	return svg.append("g").attr("transform", `translate(${center.x}, ${center.y})`);
+}, "drawFrame");
+var drawGraticule = /* @__PURE__ */ __name((g, axes, radius, ticks, graticule) => {
+	if (graticule === "circle") for (let i = 0; i < ticks; i++) {
+		const r = radius * (i + 1) / ticks;
+		g.append("circle").attr("r", r).attr("class", "radarGraticule");
+	}
+	else if (graticule === "polygon") {
+		const numAxes = axes.length;
+		for (let i = 0; i < ticks; i++) {
+			const r = radius * (i + 1) / ticks;
+			const points = axes.map((_, j) => {
+				const angle = 2 * j * Math.PI / numAxes - Math.PI / 2;
+				return `${r * Math.cos(angle)},${r * Math.sin(angle)}`;
+			}).join(" ");
+			g.append("polygon").attr("points", points).attr("class", "radarGraticule");
+		}
+	}
+}, "drawGraticule");
+var drawAxes = /* @__PURE__ */ __name((g, axes, radius, config) => {
+	const numAxes = axes.length;
+	for (let i = 0; i < numAxes; i++) {
+		const label = axes[i].label;
+		const angle = 2 * i * Math.PI / numAxes - Math.PI / 2;
+		const cosA = Math.cos(angle);
+		const sinA = Math.sin(angle);
+		g.append("line").attr("x1", 0).attr("y1", 0).attr("x2", radius * config.axisScaleFactor * cosA).attr("y2", radius * config.axisScaleFactor * sinA).attr("class", "radarAxisLine");
+		const textAnchor = cosA > .01 ? "start" : cosA < -.01 ? "end" : "middle";
+		const dominantBaseline = sinA > .01 ? "hanging" : sinA < -.01 ? "auto" : "central";
+		const labelPad = 4;
+		g.append("text").text(label).attr("x", radius * config.axisLabelFactor * cosA + labelPad * cosA).attr("y", radius * config.axisLabelFactor * sinA + labelPad * sinA).attr("text-anchor", textAnchor).attr("dominant-baseline", dominantBaseline).attr("class", "radarAxisLabel");
+	}
+}, "drawAxes");
+function drawCurves(g, axes, curves, minValue, maxValue, graticule, config) {
+	const numAxes = axes.length;
+	const radius = Math.min(config.width, config.height) / 2;
+	curves.forEach((curve, index) => {
+		if (curve.entries.length !== numAxes) return;
+		const points = curve.entries.map((entry, i) => {
+			const angle = 2 * Math.PI * i / numAxes - Math.PI / 2;
+			const r = relativeRadius(entry, minValue, maxValue, radius);
+			return {
+				x: r * Math.cos(angle),
+				y: r * Math.sin(angle)
+			};
+		});
+		if (graticule === "circle") g.append("path").attr("d", closedRoundCurve(points, config.curveTension)).attr("class", `radarCurve-${index}`);
+		else if (graticule === "polygon") g.append("polygon").attr("points", points.map((p) => `${p.x},${p.y}`).join(" ")).attr("class", `radarCurve-${index}`);
+	});
+}
+__name(drawCurves, "drawCurves");
+function relativeRadius(value, minValue, maxValue, radius) {
+	return radius * (Math.min(Math.max(value, minValue), maxValue) - minValue) / (maxValue - minValue);
+}
+__name(relativeRadius, "relativeRadius");
+function closedRoundCurve(points, tension) {
+	const numPoints = points.length;
+	let d = `M${points[0].x},${points[0].y}`;
+	for (let i = 0; i < numPoints; i++) {
+		const p0 = points[(i - 1 + numPoints) % numPoints];
+		const p1 = points[i];
+		const p2 = points[(i + 1) % numPoints];
+		const p3 = points[(i + 2) % numPoints];
+		const cp1 = {
+			x: p1.x + (p2.x - p0.x) * tension,
+			y: p1.y + (p2.y - p0.y) * tension
+		};
+		const cp2 = {
+			x: p2.x - (p3.x - p1.x) * tension,
+			y: p2.y - (p3.y - p1.y) * tension
+		};
+		d += ` C${cp1.x},${cp1.y} ${cp2.x},${cp2.y} ${p2.x},${p2.y}`;
+	}
+	return `${d} Z`;
+}
+__name(closedRoundCurve, "closedRoundCurve");
+function drawLegend(g, curves, showLegend, config) {
+	if (!showLegend) return;
+	const legendX = (config.width / 2 + config.marginRight) * 3 / 4;
+	const legendY = -(config.height / 2 + config.marginTop) * 3 / 4;
+	const lineHeight = 20;
+	curves.forEach((curve, index) => {
+		const itemGroup = g.append("g").attr("transform", `translate(${legendX}, ${legendY + index * lineHeight})`);
+		itemGroup.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${index}`);
+		itemGroup.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(curve.label);
+	});
+}
+__name(drawLegend, "drawLegend");
+var renderer = { draw };
+var genIndexStyles = /* @__PURE__ */ __name((themeVariables, radarOptions) => {
+	let sections = "";
+	for (let i = 0; i < themeVariables.THEME_COLOR_LIMIT; i++) {
+		const indexColor = themeVariables[`cScale${i}`];
+		sections += `
+		.radarCurve-${i} {
+			color: ${indexColor};
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+			stroke-width: ${radarOptions.curveStrokeWidth};
+		}
+		.radarLegendBox-${i} {
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+		}
+		`;
+	}
+	return sections;
+}, "genIndexStyles");
+var buildRadarStyleOptions = /* @__PURE__ */ __name((radar) => {
+	const themeVariables = cleanAndMerge(getThemeVariables3(), getConfig().themeVariables);
+	return {
+		themeVariables,
+		radarOptions: cleanAndMerge(themeVariables.radar, radar)
+	};
+}, "buildRadarStyleOptions");
+var diagram = {
+	parser,
+	db,
+	renderer,
+	styles: /* @__PURE__ */ __name(({ radar } = {}) => {
+		const { themeVariables, radarOptions } = buildRadarStyleOptions(radar);
+		return `
+	.radarTitle {
+		font-size: ${themeVariables.fontSize};
+		color: ${themeVariables.titleColor};
+		dominant-baseline: hanging;
+		text-anchor: middle;
+	}
+	.radarAxisLine {
+		stroke: ${radarOptions.axisColor};
+		stroke-width: ${radarOptions.axisStrokeWidth};
+	}
+	.radarAxisLabel {
+		font-size: ${radarOptions.axisLabelFontSize}px;
+		color: ${radarOptions.axisColor};
+	}
+	.radarGraticule {
+		fill: ${radarOptions.graticuleColor};
+		fill-opacity: ${radarOptions.graticuleOpacity};
+		stroke: ${radarOptions.graticuleColor};
+		stroke-width: ${radarOptions.graticuleStrokeWidth};
+	}
+	.radarLegendText {
+		text-anchor: start;
+		font-size: ${radarOptions.legendFontSize}px;
+		dominant-baseline: hanging;
+	}
+	${genIndexStyles(themeVariables, radarOptions)}
+	`;
+	}, "styles")
+};
+
+//#endregion
+export { diagram };

package/dist/dist-UajCDt3n.js

@@ -0,0 +1,92 @@
+import { t as __commonJSMin } from "./rolldown-runtime-BHkdefai.js";
+
+//#region ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/math.js
+const abs = Math.abs;
+const atan2 = Math.atan2;
+const cos = Math.cos;
+const max = Math.max;
+const min = Math.min;
+const sin = Math.sin;
+const sqrt = Math.sqrt;
+const epsilon = 1e-12;
+const pi = Math.PI;
+const halfPi = pi / 2;
+const tau = 2 * pi;
+function acos(x) {
+	return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+function asin(x) {
+	return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.2/node_modules/@braintree/sanitize-url/dist/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.BLANK_URL = exports.relativeFirstCharacters = exports.whitespaceEscapeCharsRegex = exports.urlSchemeRegex = exports.ctrlCharactersRegex = exports.htmlCtrlEntityRegex = exports.htmlEntitiesRegex = exports.invalidProtocolRegex = void 0;
+	exports.invalidProtocolRegex = /^([^\w]*)(javascript|data|vbscript)/im;
+	exports.htmlEntitiesRegex = /&#(\w+)(^\w|;)?/g;
+	exports.htmlCtrlEntityRegex = /&(newline|tab);/gi;
+	exports.ctrlCharactersRegex = /[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;
+	exports.urlSchemeRegex = /^.+(:|&colon;)/gim;
+	exports.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
+	exports.relativeFirstCharacters = [".", "/"];
+	exports.BLANK_URL = "about:blank";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.2/node_modules/@braintree/sanitize-url/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.sanitizeUrl = sanitizeUrl;
+	var constants_1 = require_constants();
+	function isRelativeUrlWithoutProtocol(url) {
+		return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
+	}
+	function decodeHtmlCharacters(str) {
+		return str.replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.htmlEntitiesRegex, function(match, dec) {
+			return String.fromCharCode(dec);
+		});
+	}
+	function isValidUrl(url) {
+		return URL.canParse(url);
+	}
+	function decodeURI(uri) {
+		try {
+			return decodeURIComponent(uri);
+		} catch (e) {
+			return uri;
+		}
+	}
+	function sanitizeUrl(url) {
+		if (!url) return constants_1.BLANK_URL;
+		var charsToDecode;
+		var decodedUrl = decodeURI(url.trim());
+		do {
+			decodedUrl = decodeHtmlCharacters(decodedUrl).replace(constants_1.htmlCtrlEntityRegex, "").replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.whitespaceEscapeCharsRegex, "").trim();
+			decodedUrl = decodeURI(decodedUrl);
+			charsToDecode = decodedUrl.match(constants_1.ctrlCharactersRegex) || decodedUrl.match(constants_1.htmlEntitiesRegex) || decodedUrl.match(constants_1.htmlCtrlEntityRegex) || decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);
+		} while (charsToDecode && charsToDecode.length > 0);
+		var sanitizedUrl = decodedUrl;
+		if (!sanitizedUrl) return constants_1.BLANK_URL;
+		if (isRelativeUrlWithoutProtocol(sanitizedUrl)) return sanitizedUrl;
+		var trimmedUrl = sanitizedUrl.trimStart();
+		var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);
+		if (!urlSchemeParseResults) return sanitizedUrl;
+		var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();
+		if (constants_1.invalidProtocolRegex.test(urlScheme)) return constants_1.BLANK_URL;
+		var backSanitized = trimmedUrl.replace(/\\/g, "/");
+		if (urlScheme === "mailto:" || urlScheme.includes("://")) return backSanitized;
+		if (urlScheme === "http:" || urlScheme === "https:") {
+			if (!isValidUrl(backSanitized)) return constants_1.BLANK_URL;
+			var url_1 = new URL(backSanitized);
+			url_1.protocol = url_1.protocol.toLowerCase();
+			url_1.hostname = url_1.hostname.toLowerCase();
+			return url_1.toString();
+		}
+		return backSanitized;
+	}
+}));
+
+//#endregion
+export { atan2 as a, halfPi as c, pi as d, sin as f, asin as i, max as l, tau as m, abs as n, cos as o, sqrt as p, acos as r, epsilon as s, require_dist as t, min as u };

package/dist/ebnfDiagram-ZINNZB2B-CI8liCfR.js

@@ -0,0 +1,123 @@
+import { f as createRailroadEbnfServices, t as MermaidParseError } from "./mermaid-parser.core-pYR5siSx.js";
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log } from "./src-NkhI3UMl.js";
+import "./chunk-O7XYJQB3-B6K0KOSL.js";
+import "./chunk-6AEJRKK7-JXK89I-O.js";
+import { n as getStyles, r as renderer, t as db } from "./chunk-GTNCS2PH-CLmh4I2c.js";
+import { t as populateCommonDb } from "./chunk-JWPE2WC7-D1rC79GS.js";
+
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/ebnfDiagram-ZINNZB2B.mjs
+var langiumParser = createRailroadEbnfServices().RailroadEbnf.parser.LangiumParser;
+var transformChoice = /* @__PURE__ */ __name((choice) => {
+	const alternatives = choice.alternatives.map(transformSequence);
+	if (alternatives.length === 1) return alternatives[0];
+	return {
+		type: "choice",
+		alternatives
+	};
+}, "transformChoice");
+var transformSequence = /* @__PURE__ */ __name((sequence) => {
+	const elements = sequence.elements.map(transformTerm);
+	if (elements.length === 1) return elements[0];
+	return {
+		type: "sequence",
+		elements
+	};
+}, "transformSequence");
+var transformPrimary = /* @__PURE__ */ __name((primary) => {
+	switch (primary.$type) {
+		case "EbnfTerminal": return {
+			type: "terminal",
+			value: primary.value
+		};
+		case "EbnfNonTerminal": return {
+			type: "nonterminal",
+			name: primary.name
+		};
+		case "EbnfSpecial": return {
+			type: "special",
+			text: primary.text
+		};
+		case "EbnfGroup": return transformChoice(primary.element);
+		case "EbnfOptional": return {
+			type: "optional",
+			element: transformChoice(primary.element)
+		};
+		case "EbnfRepetition": return {
+			type: "repetition",
+			element: transformChoice(primary.element),
+			min: 0,
+			max: Infinity
+		};
+		default: throw new Error(`Unsupported EBNF primary node: ${primary.$type}`);
+	}
+}, "transformPrimary");
+var transformPostfix = /* @__PURE__ */ __name((node, postfix) => {
+	switch (postfix.$type) {
+		case "EbnfOptionalPostfix": return {
+			type: "optional",
+			element: node
+		};
+		case "EbnfZeroOrMorePostfix": return {
+			type: "repetition",
+			element: node,
+			min: 0,
+			max: Infinity
+		};
+		case "EbnfOneOrMorePostfix": return {
+			type: "repetition",
+			element: node,
+			min: 1,
+			max: Infinity
+		};
+		case "EbnfExceptionPostfix": return {
+			type: "sequence",
+			elements: [
+				node,
+				{
+					type: "terminal",
+					value: "-"
+				},
+				transformPrimary(postfix.except)
+			]
+		};
+		default: throw new Error(`Unsupported EBNF postfix node: ${postfix.$type}`);
+	}
+}, "transformPostfix");
+var transformTerm = /* @__PURE__ */ __name((term) => {
+	return term.postfixes.reduce((currentNode, postfix) => {
+		return transformPostfix(currentNode, postfix);
+	}, transformPrimary(term.base));
+}, "transformTerm");
+var transformRule = /* @__PURE__ */ __name((rule) => {
+	return {
+		name: rule.name,
+		definition: transformChoice(rule.definition)
+	};
+}, "transformRule");
+var populateDb = /* @__PURE__ */ __name((ast) => {
+	populateCommonDb(ast, db);
+	if (ast.title) db.setTitle(ast.title);
+	ast.rules.map((rule) => db.addRule(transformRule(rule)));
+}, "populateDb");
+var diagram = {
+	parser: {
+		parse: /* @__PURE__ */ __name((input) => {
+			db.clear();
+			log.debug("[EBNF Parser] Starting Langium parse");
+			const result = langiumParser.parse(input);
+			if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) throw new MermaidParseError(result);
+			const ast = result.value;
+			log.debug("[EBNF Parser] Parsed rules:", ast.rules.length);
+			populateDb(ast);
+			log.debug("[EBNF Parser] Parse complete");
+		}, "parse"),
+		parser: { yy: db }
+	},
+	db,
+	renderer,
+	styles: getStyles
+};
+
+//#endregion
+export { diagram };