Chen Xiao
Generated
Vendored
+13
@@ -0,0 +1,13 @@
|
||||
import {
|
||||
ArchitectureModule,
|
||||
createArchitectureServices
|
||||
} from "./chunk-P6XZ56Y6.mjs";
|
||||
import "./chunk-WEB62QT6.mjs";
|
||||
import "./chunk-MFRUYFWM.mjs";
|
||||
import "./chunk-UKL4YMJ2.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import "./chunk-FQFHLQFH.mjs";
|
||||
export {
|
||||
ArchitectureModule,
|
||||
createArchitectureServices
|
||||
};
|
||||
Generated
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": [],
|
||||
"sourcesContent": [],
|
||||
"mappings": "",
|
||||
"names": []
|
||||
}
|
||||
Generated
Vendored
+8955
File diff suppressed because it is too large
Load Diff
Generated
Vendored
+7
File diff suppressed because one or more lines are too long
+3820
File diff suppressed because it is too large
Load Diff
Generated
Vendored
+7
File diff suppressed because one or more lines are too long
+2605
File diff suppressed because one or more lines are too long
+7
File diff suppressed because one or more lines are too long
+26
@@ -0,0 +1,26 @@
|
||||
import {
|
||||
getConfig2 as getConfig
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
select_default
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/rendering-util/selectSvgElement.ts
|
||||
var selectSvgElement = /* @__PURE__ */ __name((id) => {
|
||||
const { securityLevel } = getConfig();
|
||||
let root = select_default("body");
|
||||
if (securityLevel === "sandbox") {
|
||||
const sandboxElement = select_default(`#i${id}`);
|
||||
const doc = sandboxElement.node()?.contentDocument ?? document;
|
||||
root = select_default(doc.body);
|
||||
}
|
||||
const svg = root.select(`#${id}`);
|
||||
return svg;
|
||||
}, "selectSvgElement");
|
||||
|
||||
export {
|
||||
selectSvgElement
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/rendering-util/selectSvgElement.ts"],
|
||||
"sourcesContent": ["import { select } from 'd3';\nimport { getConfig } from '../diagram-api/diagramAPI.js';\nimport type { HTML, SVG } from '../diagram-api/types.js';\n\n/**\n * Selects the SVG element using {@link id}.\n *\n * @param id - The diagram ID.\n * @returns The selected {@link SVG} element using {@link id}.\n */\nexport const selectSvgElement = (id: string): SVG => {\n const { securityLevel } = getConfig();\n // handle root and document for when rendering in sandbox mode\n let root: HTML = select('body');\n if (securityLevel === 'sandbox') {\n const sandboxElement: HTML = select(`#i${id}`);\n const doc: Document = sandboxElement.node()?.contentDocument ?? document;\n root = select(doc.body as HTMLIFrameElement);\n }\n const svg: SVG = root.select(`#${id}`);\n return svg;\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;AAUO,IAAM,mBAAmB,wBAAC,OAAoB;AACnD,QAAM,EAAE,cAAc,IAAI,UAAU;AAEpC,MAAI,OAAa,eAAO,MAAM;AAC9B,MAAI,kBAAkB,WAAW;AAC/B,UAAM,iBAAuB,eAAO,KAAK,EAAE,EAAE;AAC7C,UAAM,MAAgB,eAAe,KAAK,GAAG,mBAAmB;AAChE,WAAO,eAAO,IAAI,IAAyB;AAAA,EAC7C;AACA,QAAM,MAAW,KAAK,OAAO,IAAI,EAAE,EAAE;AACrC,SAAO;AACT,GAXgC;",
|
||||
"names": []
|
||||
}
|
||||
+1055
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+102
@@ -0,0 +1,102 @@
|
||||
import {
|
||||
__commonJS,
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js
|
||||
var require_constants = __commonJS({
|
||||
"../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js"(exports) {
|
||||
"use strict";
|
||||
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 = /^.+(:|:)/gim;
|
||||
exports.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
|
||||
exports.relativeFirstCharacters = [".", "/"];
|
||||
exports.BLANK_URL = "about:blank";
|
||||
}
|
||||
});
|
||||
|
||||
// ../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js
|
||||
var require_dist = __commonJS({
|
||||
"../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js"(exports) {
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.sanitizeUrl = void 0;
|
||||
var constants_1 = require_constants();
|
||||
function isRelativeUrlWithoutProtocol(url) {
|
||||
return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
|
||||
}
|
||||
__name(isRelativeUrlWithoutProtocol, "isRelativeUrlWithoutProtocol");
|
||||
function decodeHtmlCharacters(str) {
|
||||
var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, "");
|
||||
return removedNullByte.replace(constants_1.htmlEntitiesRegex, function(match, dec) {
|
||||
return String.fromCharCode(dec);
|
||||
});
|
||||
}
|
||||
__name(decodeHtmlCharacters, "decodeHtmlCharacters");
|
||||
function isValidUrl(url) {
|
||||
return URL.canParse(url);
|
||||
}
|
||||
__name(isValidUrl, "isValidUrl");
|
||||
function decodeURI(uri) {
|
||||
try {
|
||||
return decodeURIComponent(uri);
|
||||
} catch (e) {
|
||||
return uri;
|
||||
}
|
||||
}
|
||||
__name(decodeURI, "decodeURI");
|
||||
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;
|
||||
}
|
||||
__name(sanitizeUrl, "sanitizeUrl");
|
||||
exports.sanitizeUrl = sanitizeUrl;
|
||||
}
|
||||
});
|
||||
|
||||
export {
|
||||
require_dist
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.js", "../../../../../node_modules/.pnpm/@braintree+sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.js"],
|
||||
"sourcesContent": ["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BLANK_URL = exports.relativeFirstCharacters = exports.whitespaceEscapeCharsRegex = exports.urlSchemeRegex = exports.ctrlCharactersRegex = exports.htmlCtrlEntityRegex = exports.htmlEntitiesRegex = exports.invalidProtocolRegex = void 0;\nexports.invalidProtocolRegex = /^([^\\w]*)(javascript|data|vbscript)/im;\nexports.htmlEntitiesRegex = /&#(\\w+)(^\\w|;)?/g;\nexports.htmlCtrlEntityRegex = /&(newline|tab);/gi;\nexports.ctrlCharactersRegex = /[\\u0000-\\u001F\\u007F-\\u009F\\u2000-\\u200D\\uFEFF]/gim;\nexports.urlSchemeRegex = /^.+(:|:)/gim;\nexports.whitespaceEscapeCharsRegex = /(\\\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;\nexports.relativeFirstCharacters = [\".\", \"/\"];\nexports.BLANK_URL = \"about:blank\";\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sanitizeUrl = void 0;\nvar constants_1 = require(\"./constants\");\nfunction isRelativeUrlWithoutProtocol(url) {\n return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;\n}\nfunction decodeHtmlCharacters(str) {\n var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, \"\");\n return removedNullByte.replace(constants_1.htmlEntitiesRegex, function (match, dec) {\n return String.fromCharCode(dec);\n });\n}\nfunction isValidUrl(url) {\n return URL.canParse(url);\n}\nfunction decodeURI(uri) {\n try {\n return decodeURIComponent(uri);\n }\n catch (e) {\n // Ignoring error\n // It is possible that the URI contains a `%` not associated\n // with URI/URL-encoding.\n return uri;\n }\n}\nfunction sanitizeUrl(url) {\n if (!url) {\n return constants_1.BLANK_URL;\n }\n var charsToDecode;\n var decodedUrl = decodeURI(url.trim());\n do {\n decodedUrl = decodeHtmlCharacters(decodedUrl)\n .replace(constants_1.htmlCtrlEntityRegex, \"\")\n .replace(constants_1.ctrlCharactersRegex, \"\")\n .replace(constants_1.whitespaceEscapeCharsRegex, \"\")\n .trim();\n decodedUrl = decodeURI(decodedUrl);\n charsToDecode =\n decodedUrl.match(constants_1.ctrlCharactersRegex) ||\n decodedUrl.match(constants_1.htmlEntitiesRegex) ||\n decodedUrl.match(constants_1.htmlCtrlEntityRegex) ||\n decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);\n } while (charsToDecode && charsToDecode.length > 0);\n var sanitizedUrl = decodedUrl;\n if (!sanitizedUrl) {\n return constants_1.BLANK_URL;\n }\n if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {\n return sanitizedUrl;\n }\n // Remove any leading whitespace before checking the URL scheme\n var trimmedUrl = sanitizedUrl.trimStart();\n var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);\n if (!urlSchemeParseResults) {\n return sanitizedUrl;\n }\n var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();\n if (constants_1.invalidProtocolRegex.test(urlScheme)) {\n return constants_1.BLANK_URL;\n }\n var backSanitized = trimmedUrl.replace(/\\\\/g, \"/\");\n // Handle special cases for mailto: and custom deep-link protocols\n if (urlScheme === \"mailto:\" || urlScheme.includes(\"://\")) {\n return backSanitized;\n }\n // For http and https URLs, perform additional validation\n if (urlScheme === \"http:\" || urlScheme === \"https:\") {\n if (!isValidUrl(backSanitized)) {\n return constants_1.BLANK_URL;\n }\n var url_1 = new URL(backSanitized);\n url_1.protocol = url_1.protocol.toLowerCase();\n url_1.hostname = url_1.hostname.toLowerCase();\n return url_1.toString();\n }\n return backSanitized;\n}\nexports.sanitizeUrl = sanitizeUrl;\n"],
|
||||
"mappings": ";;;;;;AAAA;AAAA;AAAA;AACA,WAAO,eAAe,SAAS,cAAc,EAAE,OAAO,KAAK,CAAC;AAC5D,YAAQ,YAAY,QAAQ,0BAA0B,QAAQ,6BAA6B,QAAQ,iBAAiB,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ,oBAAoB,QAAQ,uBAAuB;AAC3O,YAAQ,uBAAuB;AAC/B,YAAQ,oBAAoB;AAC5B,YAAQ,sBAAsB;AAC9B,YAAQ,sBAAsB;AAC9B,YAAQ,iBAAiB;AACzB,YAAQ,6BAA6B;AACrC,YAAQ,0BAA0B,CAAC,KAAK,GAAG;AAC3C,YAAQ,YAAY;AAAA;AAAA;;;ACVpB;AAAA;AAAA;AACA,WAAO,eAAe,SAAS,cAAc,EAAE,OAAO,KAAK,CAAC;AAC5D,YAAQ,cAAc;AACtB,QAAI,cAAc;AAClB,aAAS,6BAA6B,KAAK;AACvC,aAAO,YAAY,wBAAwB,QAAQ,IAAI,CAAC,CAAC,IAAI;AAAA,IACjE;AAFS;AAGT,aAAS,qBAAqB,KAAK;AAC/B,UAAI,kBAAkB,IAAI,QAAQ,YAAY,qBAAqB,EAAE;AACrE,aAAO,gBAAgB,QAAQ,YAAY,mBAAmB,SAAU,OAAO,KAAK;AAChF,eAAO,OAAO,aAAa,GAAG;AAAA,MAClC,CAAC;AAAA,IACL;AALS;AAMT,aAAS,WAAW,KAAK;AACrB,aAAO,IAAI,SAAS,GAAG;AAAA,IAC3B;AAFS;AAGT,aAAS,UAAU,KAAK;AACpB,UAAI;AACA,eAAO,mBAAmB,GAAG;AAAA,MACjC,SACO,GAAG;AAIN,eAAO;AAAA,MACX;AAAA,IACJ;AAVS;AAWT,aAAS,YAAY,KAAK;AACtB,UAAI,CAAC,KAAK;AACN,eAAO,YAAY;AAAA,MACvB;AACA,UAAI;AACJ,UAAI,aAAa,UAAU,IAAI,KAAK,CAAC;AACrC,SAAG;AACC,qBAAa,qBAAqB,UAAU,EACvC,QAAQ,YAAY,qBAAqB,EAAE,EAC3C,QAAQ,YAAY,qBAAqB,EAAE,EAC3C,QAAQ,YAAY,4BAA4B,EAAE,EAClD,KAAK;AACV,qBAAa,UAAU,UAAU;AACjC,wBACI,WAAW,MAAM,YAAY,mBAAmB,KAC5C,WAAW,MAAM,YAAY,iBAAiB,KAC9C,WAAW,MAAM,YAAY,mBAAmB,KAChD,WAAW,MAAM,YAAY,0BAA0B;AAAA,MACnE,SAAS,iBAAiB,cAAc,SAAS;AACjD,UAAI,eAAe;AACnB,UAAI,CAAC,cAAc;AACf,eAAO,YAAY;AAAA,MACvB;AACA,UAAI,6BAA6B,YAAY,GAAG;AAC5C,eAAO;AAAA,MACX;AAEA,UAAI,aAAa,aAAa,UAAU;AACxC,UAAI,wBAAwB,WAAW,MAAM,YAAY,cAAc;AACvE,UAAI,CAAC,uBAAuB;AACxB,eAAO;AAAA,MACX;AACA,UAAI,YAAY,sBAAsB,CAAC,EAAE,YAAY,EAAE,KAAK;AAC5D,UAAI,YAAY,qBAAqB,KAAK,SAAS,GAAG;AAClD,eAAO,YAAY;AAAA,MACvB;AACA,UAAI,gBAAgB,WAAW,QAAQ,OAAO,GAAG;AAEjD,UAAI,cAAc,aAAa,UAAU,SAAS,KAAK,GAAG;AACtD,eAAO;AAAA,MACX;AAEA,UAAI,cAAc,WAAW,cAAc,UAAU;AACjD,YAAI,CAAC,WAAW,aAAa,GAAG;AAC5B,iBAAO,YAAY;AAAA,QACvB;AACA,YAAI,QAAQ,IAAI,IAAI,aAAa;AACjC,cAAM,WAAW,MAAM,SAAS,YAAY;AAC5C,cAAM,WAAW,MAAM,SAAS,YAAY;AAC5C,eAAO,MAAM,SAAS;AAAA,MAC1B;AACA,aAAO;AAAA,IACX;AApDS;AAqDT,YAAQ,cAAc;AAAA;AAAA;",
|
||||
"names": []
|
||||
}
|
||||
+1191
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+591
@@ -0,0 +1,591 @@
|
||||
import {
|
||||
require_dist
|
||||
} from "./chunk-3OTVAOVH.mjs";
|
||||
import {
|
||||
assignWithDepth_default,
|
||||
common_default,
|
||||
detectType,
|
||||
directiveRegex,
|
||||
sanitizeDirective
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
basisClosed_default,
|
||||
basisOpen_default,
|
||||
basis_default,
|
||||
bumpX,
|
||||
bumpY,
|
||||
bundle_default,
|
||||
cardinalClosed_default,
|
||||
cardinalOpen_default,
|
||||
cardinal_default,
|
||||
catmullRomClosed_default,
|
||||
catmullRomOpen_default,
|
||||
catmullRom_default,
|
||||
linearClosed_default,
|
||||
linear_default,
|
||||
log,
|
||||
monotoneX,
|
||||
monotoneY,
|
||||
natural_default,
|
||||
select_default,
|
||||
stepAfter,
|
||||
stepBefore,
|
||||
step_default
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
memoize_default,
|
||||
merge_default
|
||||
} from "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name,
|
||||
__toESM
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/utils.ts
|
||||
var import_sanitize_url = __toESM(require_dist(), 1);
|
||||
var ZERO_WIDTH_SPACE = "\u200B";
|
||||
var d3CurveTypes = {
|
||||
curveBasis: basis_default,
|
||||
curveBasisClosed: basisClosed_default,
|
||||
curveBasisOpen: basisOpen_default,
|
||||
curveBumpX: bumpX,
|
||||
curveBumpY: bumpY,
|
||||
curveBundle: bundle_default,
|
||||
curveCardinalClosed: cardinalClosed_default,
|
||||
curveCardinalOpen: cardinalOpen_default,
|
||||
curveCardinal: cardinal_default,
|
||||
curveCatmullRomClosed: catmullRomClosed_default,
|
||||
curveCatmullRomOpen: catmullRomOpen_default,
|
||||
curveCatmullRom: catmullRom_default,
|
||||
curveLinear: linear_default,
|
||||
curveLinearClosed: linearClosed_default,
|
||||
curveMonotoneX: monotoneX,
|
||||
curveMonotoneY: monotoneY,
|
||||
curveNatural: natural_default,
|
||||
curveStep: step_default,
|
||||
curveStepAfter: stepAfter,
|
||||
curveStepBefore: stepBefore
|
||||
};
|
||||
var directiveWithoutOpen = /\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi;
|
||||
var detectInit = /* @__PURE__ */ __name(function(text, config) {
|
||||
const inits = detectDirective(text, /(?:init\b)|(?:initialize\b)/);
|
||||
let results = {};
|
||||
if (Array.isArray(inits)) {
|
||||
const args = inits.map((init) => init.args);
|
||||
sanitizeDirective(args);
|
||||
results = assignWithDepth_default(results, [...args]);
|
||||
} else {
|
||||
results = inits.args;
|
||||
}
|
||||
if (!results) {
|
||||
return;
|
||||
}
|
||||
let type = detectType(text, config);
|
||||
const prop = "config";
|
||||
if (results[prop] !== void 0) {
|
||||
if (type === "flowchart-v2") {
|
||||
type = "flowchart";
|
||||
}
|
||||
results[type] = results[prop];
|
||||
delete results[prop];
|
||||
}
|
||||
return results;
|
||||
}, "detectInit");
|
||||
var detectDirective = /* @__PURE__ */ __name(function(text, type = null) {
|
||||
try {
|
||||
const commentWithoutDirectives = new RegExp(
|
||||
`[%]{2}(?![{]${directiveWithoutOpen.source})(?=[}][%]{2}).*
|
||||
`,
|
||||
"ig"
|
||||
);
|
||||
text = text.trim().replace(commentWithoutDirectives, "").replace(/'/gm, '"');
|
||||
log.debug(
|
||||
`Detecting diagram directive${type !== null ? " type:" + type : ""} based on the text:${text}`
|
||||
);
|
||||
let match;
|
||||
const result = [];
|
||||
while ((match = directiveRegex.exec(text)) !== null) {
|
||||
if (match.index === directiveRegex.lastIndex) {
|
||||
directiveRegex.lastIndex++;
|
||||
}
|
||||
if (match && !type || type && match[1]?.match(type) || type && match[2]?.match(type)) {
|
||||
const type2 = match[1] ? match[1] : match[2];
|
||||
const args = match[3] ? match[3].trim() : match[4] ? JSON.parse(match[4].trim()) : null;
|
||||
result.push({ type: type2, args });
|
||||
}
|
||||
}
|
||||
if (result.length === 0) {
|
||||
return { type: text, args: null };
|
||||
}
|
||||
return result.length === 1 ? result[0] : result;
|
||||
} catch (error) {
|
||||
log.error(
|
||||
`ERROR: ${error.message} - Unable to parse directive type: '${type}' based on the text: '${text}'`
|
||||
);
|
||||
return { type: void 0, args: null };
|
||||
}
|
||||
}, "detectDirective");
|
||||
var removeDirectives = /* @__PURE__ */ __name(function(text) {
|
||||
return text.replace(directiveRegex, "");
|
||||
}, "removeDirectives");
|
||||
var isSubstringInArray = /* @__PURE__ */ __name(function(str, arr) {
|
||||
for (const [i, element] of arr.entries()) {
|
||||
if (element.match(str)) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}, "isSubstringInArray");
|
||||
function interpolateToCurve(interpolate, defaultCurve) {
|
||||
if (!interpolate) {
|
||||
return defaultCurve;
|
||||
}
|
||||
const curveName = `curve${interpolate.charAt(0).toUpperCase() + interpolate.slice(1)}`;
|
||||
return d3CurveTypes[curveName] ?? defaultCurve;
|
||||
}
|
||||
__name(interpolateToCurve, "interpolateToCurve");
|
||||
function formatUrl(linkStr, config) {
|
||||
const url = linkStr.trim();
|
||||
if (!url) {
|
||||
return void 0;
|
||||
}
|
||||
if (config.securityLevel !== "loose") {
|
||||
return (0, import_sanitize_url.sanitizeUrl)(url);
|
||||
}
|
||||
return url;
|
||||
}
|
||||
__name(formatUrl, "formatUrl");
|
||||
var runFunc = /* @__PURE__ */ __name((functionName, ...params) => {
|
||||
const arrPaths = functionName.split(".");
|
||||
const len = arrPaths.length - 1;
|
||||
const fnName = arrPaths[len];
|
||||
let obj = window;
|
||||
for (let i = 0; i < len; i++) {
|
||||
obj = obj[arrPaths[i]];
|
||||
if (!obj) {
|
||||
log.error(`Function name: ${functionName} not found in window`);
|
||||
return;
|
||||
}
|
||||
}
|
||||
obj[fnName](...params);
|
||||
}, "runFunc");
|
||||
function distance(p1, p2) {
|
||||
if (!p1 || !p2) {
|
||||
return 0;
|
||||
}
|
||||
return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
|
||||
}
|
||||
__name(distance, "distance");
|
||||
function traverseEdge(points) {
|
||||
let prevPoint;
|
||||
let totalDistance = 0;
|
||||
points.forEach((point) => {
|
||||
totalDistance += distance(point, prevPoint);
|
||||
prevPoint = point;
|
||||
});
|
||||
const remainingDistance = totalDistance / 2;
|
||||
return calculatePoint(points, remainingDistance);
|
||||
}
|
||||
__name(traverseEdge, "traverseEdge");
|
||||
function calcLabelPosition(points) {
|
||||
if (points.length === 1) {
|
||||
return points[0];
|
||||
}
|
||||
return traverseEdge(points);
|
||||
}
|
||||
__name(calcLabelPosition, "calcLabelPosition");
|
||||
var roundNumber = /* @__PURE__ */ __name((num, precision = 2) => {
|
||||
const factor = Math.pow(10, precision);
|
||||
return Math.round(num * factor) / factor;
|
||||
}, "roundNumber");
|
||||
var calculatePoint = /* @__PURE__ */ __name((points, distanceToTraverse) => {
|
||||
let prevPoint = void 0;
|
||||
let remainingDistance = distanceToTraverse;
|
||||
for (const point of points) {
|
||||
if (prevPoint) {
|
||||
const vectorDistance = distance(point, prevPoint);
|
||||
if (vectorDistance === 0) {
|
||||
return prevPoint;
|
||||
}
|
||||
if (vectorDistance < remainingDistance) {
|
||||
remainingDistance -= vectorDistance;
|
||||
} else {
|
||||
const distanceRatio = remainingDistance / vectorDistance;
|
||||
if (distanceRatio <= 0) {
|
||||
return prevPoint;
|
||||
}
|
||||
if (distanceRatio >= 1) {
|
||||
return { x: point.x, y: point.y };
|
||||
}
|
||||
if (distanceRatio > 0 && distanceRatio < 1) {
|
||||
return {
|
||||
x: roundNumber((1 - distanceRatio) * prevPoint.x + distanceRatio * point.x, 5),
|
||||
y: roundNumber((1 - distanceRatio) * prevPoint.y + distanceRatio * point.y, 5)
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
prevPoint = point;
|
||||
}
|
||||
throw new Error("Could not find a suitable point for the given distance");
|
||||
}, "calculatePoint");
|
||||
var calcCardinalityPosition = /* @__PURE__ */ __name((isRelationTypePresent, points, initialPosition) => {
|
||||
log.info(`our points ${JSON.stringify(points)}`);
|
||||
if (points[0] !== initialPosition) {
|
||||
points = points.reverse();
|
||||
}
|
||||
const distanceToCardinalityPoint = 25;
|
||||
const center = calculatePoint(points, distanceToCardinalityPoint);
|
||||
const d = isRelationTypePresent ? 10 : 5;
|
||||
const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
|
||||
const cardinalityPosition = { x: 0, y: 0 };
|
||||
cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
|
||||
cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
|
||||
return cardinalityPosition;
|
||||
}, "calcCardinalityPosition");
|
||||
function calcTerminalLabelPosition(terminalMarkerSize, position, _points) {
|
||||
const points = structuredClone(_points);
|
||||
log.info("our points", points);
|
||||
if (position !== "start_left" && position !== "start_right") {
|
||||
points.reverse();
|
||||
}
|
||||
const distanceToCardinalityPoint = 25 + terminalMarkerSize;
|
||||
const center = calculatePoint(points, distanceToCardinalityPoint);
|
||||
const d = 10 + terminalMarkerSize * 0.5;
|
||||
const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x);
|
||||
const cardinalityPosition = { x: 0, y: 0 };
|
||||
if (position === "start_left") {
|
||||
cardinalityPosition.x = Math.sin(angle + Math.PI) * d + (points[0].x + center.x) / 2;
|
||||
cardinalityPosition.y = -Math.cos(angle + Math.PI) * d + (points[0].y + center.y) / 2;
|
||||
} else if (position === "end_right") {
|
||||
cardinalityPosition.x = Math.sin(angle - Math.PI) * d + (points[0].x + center.x) / 2 - 5;
|
||||
cardinalityPosition.y = -Math.cos(angle - Math.PI) * d + (points[0].y + center.y) / 2 - 5;
|
||||
} else if (position === "end_left") {
|
||||
cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2 - 5;
|
||||
cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2 - 5;
|
||||
} else {
|
||||
cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2;
|
||||
cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2;
|
||||
}
|
||||
return cardinalityPosition;
|
||||
}
|
||||
__name(calcTerminalLabelPosition, "calcTerminalLabelPosition");
|
||||
function getStylesFromArray(arr) {
|
||||
let style = "";
|
||||
let labelStyle = "";
|
||||
for (const element of arr) {
|
||||
if (element !== void 0) {
|
||||
if (element.startsWith("color:") || element.startsWith("text-align:")) {
|
||||
labelStyle = labelStyle + element + ";";
|
||||
} else {
|
||||
style = style + element + ";";
|
||||
}
|
||||
}
|
||||
}
|
||||
return { style, labelStyle };
|
||||
}
|
||||
__name(getStylesFromArray, "getStylesFromArray");
|
||||
var cnt = 0;
|
||||
var generateId = /* @__PURE__ */ __name(() => {
|
||||
cnt++;
|
||||
return "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt;
|
||||
}, "generateId");
|
||||
function makeRandomHex(length) {
|
||||
let result = "";
|
||||
const characters = "0123456789abcdef";
|
||||
const charactersLength = characters.length;
|
||||
for (let i = 0; i < length; i++) {
|
||||
result += characters.charAt(Math.floor(Math.random() * charactersLength));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
__name(makeRandomHex, "makeRandomHex");
|
||||
var random = /* @__PURE__ */ __name((options) => {
|
||||
return makeRandomHex(options.length);
|
||||
}, "random");
|
||||
var getTextObj = /* @__PURE__ */ __name(function() {
|
||||
return {
|
||||
x: 0,
|
||||
y: 0,
|
||||
fill: void 0,
|
||||
anchor: "start",
|
||||
style: "#666",
|
||||
width: 100,
|
||||
height: 100,
|
||||
textMargin: 0,
|
||||
rx: 0,
|
||||
ry: 0,
|
||||
valign: void 0,
|
||||
text: ""
|
||||
};
|
||||
}, "getTextObj");
|
||||
var drawSimpleText = /* @__PURE__ */ __name(function(elem, textData) {
|
||||
const nText = textData.text.replace(common_default.lineBreakRegex, " ");
|
||||
const [, _fontSizePx] = parseFontSize(textData.fontSize);
|
||||
const textElem = elem.append("text");
|
||||
textElem.attr("x", textData.x);
|
||||
textElem.attr("y", textData.y);
|
||||
textElem.style("text-anchor", textData.anchor);
|
||||
textElem.style("font-family", textData.fontFamily);
|
||||
textElem.style("font-size", _fontSizePx);
|
||||
textElem.style("font-weight", textData.fontWeight);
|
||||
textElem.attr("fill", textData.fill);
|
||||
if (textData.class !== void 0) {
|
||||
textElem.attr("class", textData.class);
|
||||
}
|
||||
const span = textElem.append("tspan");
|
||||
span.attr("x", textData.x + textData.textMargin * 2);
|
||||
span.attr("fill", textData.fill);
|
||||
span.text(nText);
|
||||
return textElem;
|
||||
}, "drawSimpleText");
|
||||
var wrapLabel = memoize_default(
|
||||
(label, maxWidth, config) => {
|
||||
if (!label) {
|
||||
return label;
|
||||
}
|
||||
config = Object.assign(
|
||||
{ fontSize: 12, fontWeight: 400, fontFamily: "Arial", joinWith: "<br/>" },
|
||||
config
|
||||
);
|
||||
if (common_default.lineBreakRegex.test(label)) {
|
||||
return label;
|
||||
}
|
||||
const words = label.split(" ").filter(Boolean);
|
||||
const completedLines = [];
|
||||
let nextLine = "";
|
||||
words.forEach((word, index) => {
|
||||
const wordLength = calculateTextWidth(`${word} `, config);
|
||||
const nextLineLength = calculateTextWidth(nextLine, config);
|
||||
if (wordLength > maxWidth) {
|
||||
const { hyphenatedStrings, remainingWord } = breakString(word, maxWidth, "-", config);
|
||||
completedLines.push(nextLine, ...hyphenatedStrings);
|
||||
nextLine = remainingWord;
|
||||
} else if (nextLineLength + wordLength >= maxWidth) {
|
||||
completedLines.push(nextLine);
|
||||
nextLine = word;
|
||||
} else {
|
||||
nextLine = [nextLine, word].filter(Boolean).join(" ");
|
||||
}
|
||||
const currentWord = index + 1;
|
||||
const isLastWord = currentWord === words.length;
|
||||
if (isLastWord) {
|
||||
completedLines.push(nextLine);
|
||||
}
|
||||
});
|
||||
return completedLines.filter((line) => line !== "").join(config.joinWith);
|
||||
},
|
||||
(label, maxWidth, config) => `${label}${maxWidth}${config.fontSize}${config.fontWeight}${config.fontFamily}${config.joinWith}`
|
||||
);
|
||||
var breakString = memoize_default(
|
||||
(word, maxWidth, hyphenCharacter = "-", config) => {
|
||||
config = Object.assign(
|
||||
{ fontSize: 12, fontWeight: 400, fontFamily: "Arial", margin: 0 },
|
||||
config
|
||||
);
|
||||
const characters = [...word];
|
||||
const lines = [];
|
||||
let currentLine = "";
|
||||
characters.forEach((character, index) => {
|
||||
const nextLine = `${currentLine}${character}`;
|
||||
const lineWidth = calculateTextWidth(nextLine, config);
|
||||
if (lineWidth >= maxWidth) {
|
||||
const currentCharacter = index + 1;
|
||||
const isLastLine = characters.length === currentCharacter;
|
||||
const hyphenatedNextLine = `${nextLine}${hyphenCharacter}`;
|
||||
lines.push(isLastLine ? nextLine : hyphenatedNextLine);
|
||||
currentLine = "";
|
||||
} else {
|
||||
currentLine = nextLine;
|
||||
}
|
||||
});
|
||||
return { hyphenatedStrings: lines, remainingWord: currentLine };
|
||||
},
|
||||
(word, maxWidth, hyphenCharacter = "-", config) => `${word}${maxWidth}${hyphenCharacter}${config.fontSize}${config.fontWeight}${config.fontFamily}`
|
||||
);
|
||||
function calculateTextHeight(text, config) {
|
||||
return calculateTextDimensions(text, config).height;
|
||||
}
|
||||
__name(calculateTextHeight, "calculateTextHeight");
|
||||
function calculateTextWidth(text, config) {
|
||||
return calculateTextDimensions(text, config).width;
|
||||
}
|
||||
__name(calculateTextWidth, "calculateTextWidth");
|
||||
var calculateTextDimensions = memoize_default(
|
||||
(text, config) => {
|
||||
const { fontSize = 12, fontFamily = "Arial", fontWeight = 400 } = config;
|
||||
if (!text) {
|
||||
return { width: 0, height: 0 };
|
||||
}
|
||||
const [, _fontSizePx] = parseFontSize(fontSize);
|
||||
const fontFamilies = ["sans-serif", fontFamily];
|
||||
const lines = text.split(common_default.lineBreakRegex);
|
||||
const dims = [];
|
||||
const body = select_default("body");
|
||||
if (!body.remove) {
|
||||
return { width: 0, height: 0, lineHeight: 0 };
|
||||
}
|
||||
const g = body.append("svg");
|
||||
for (const fontFamily2 of fontFamilies) {
|
||||
let cHeight = 0;
|
||||
const dim = { width: 0, height: 0, lineHeight: 0 };
|
||||
for (const line of lines) {
|
||||
const textObj = getTextObj();
|
||||
textObj.text = line || ZERO_WIDTH_SPACE;
|
||||
const textElem = drawSimpleText(g, textObj).style("font-size", _fontSizePx).style("font-weight", fontWeight).style("font-family", fontFamily2);
|
||||
const bBox = (textElem._groups || textElem)[0][0].getBBox();
|
||||
if (bBox.width === 0 && bBox.height === 0) {
|
||||
throw new Error("svg element not in render tree");
|
||||
}
|
||||
dim.width = Math.round(Math.max(dim.width, bBox.width));
|
||||
cHeight = Math.round(bBox.height);
|
||||
dim.height += cHeight;
|
||||
dim.lineHeight = Math.round(Math.max(dim.lineHeight, cHeight));
|
||||
}
|
||||
dims.push(dim);
|
||||
}
|
||||
g.remove();
|
||||
const index = isNaN(dims[1].height) || isNaN(dims[1].width) || isNaN(dims[1].lineHeight) || dims[0].height > dims[1].height && dims[0].width > dims[1].width && dims[0].lineHeight > dims[1].lineHeight ? 0 : 1;
|
||||
return dims[index];
|
||||
},
|
||||
(text, config) => `${text}${config.fontSize}${config.fontWeight}${config.fontFamily}`
|
||||
);
|
||||
var InitIDGenerator = class {
|
||||
constructor(deterministic = false, seed) {
|
||||
this.count = 0;
|
||||
this.count = seed ? seed.length : 0;
|
||||
this.next = deterministic ? () => this.count++ : () => Date.now();
|
||||
}
|
||||
static {
|
||||
__name(this, "InitIDGenerator");
|
||||
}
|
||||
};
|
||||
var decoder;
|
||||
var entityDecode = /* @__PURE__ */ __name(function(html) {
|
||||
decoder = decoder || document.createElement("div");
|
||||
html = escape(html).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";");
|
||||
decoder.innerHTML = html;
|
||||
return unescape(decoder.textContent);
|
||||
}, "entityDecode");
|
||||
function isDetailedError(error) {
|
||||
return "str" in error;
|
||||
}
|
||||
__name(isDetailedError, "isDetailedError");
|
||||
var insertTitle = /* @__PURE__ */ __name((parent, cssClass, titleTopMargin, title) => {
|
||||
if (!title) {
|
||||
return;
|
||||
}
|
||||
const bounds = parent.node()?.getBBox();
|
||||
if (!bounds) {
|
||||
return;
|
||||
}
|
||||
parent.append("text").text(title).attr("text-anchor", "middle").attr("x", bounds.x + bounds.width / 2).attr("y", -titleTopMargin).attr("class", cssClass);
|
||||
}, "insertTitle");
|
||||
var parseFontSize = /* @__PURE__ */ __name((fontSize) => {
|
||||
if (typeof fontSize === "number") {
|
||||
return [fontSize, fontSize + "px"];
|
||||
}
|
||||
const fontSizeNumber = parseInt(fontSize ?? "", 10);
|
||||
if (Number.isNaN(fontSizeNumber)) {
|
||||
return [void 0, void 0];
|
||||
} else if (fontSize === String(fontSizeNumber)) {
|
||||
return [fontSizeNumber, fontSize + "px"];
|
||||
} else {
|
||||
return [fontSizeNumber, fontSize];
|
||||
}
|
||||
}, "parseFontSize");
|
||||
function cleanAndMerge(defaultData, data) {
|
||||
return merge_default({}, defaultData, data);
|
||||
}
|
||||
__name(cleanAndMerge, "cleanAndMerge");
|
||||
var utils_default = {
|
||||
assignWithDepth: assignWithDepth_default,
|
||||
wrapLabel,
|
||||
calculateTextHeight,
|
||||
calculateTextWidth,
|
||||
calculateTextDimensions,
|
||||
cleanAndMerge,
|
||||
detectInit,
|
||||
detectDirective,
|
||||
isSubstringInArray,
|
||||
interpolateToCurve,
|
||||
calcLabelPosition,
|
||||
calcCardinalityPosition,
|
||||
calcTerminalLabelPosition,
|
||||
formatUrl,
|
||||
getStylesFromArray,
|
||||
generateId,
|
||||
random,
|
||||
runFunc,
|
||||
entityDecode,
|
||||
insertTitle,
|
||||
isLabelCoordinateInPath,
|
||||
parseFontSize,
|
||||
InitIDGenerator
|
||||
};
|
||||
var encodeEntities = /* @__PURE__ */ __name(function(text) {
|
||||
let txt = text;
|
||||
txt = txt.replace(/style.*:\S*#.*;/g, function(s) {
|
||||
return s.substring(0, s.length - 1);
|
||||
});
|
||||
txt = txt.replace(/classDef.*:\S*#.*;/g, function(s) {
|
||||
return s.substring(0, s.length - 1);
|
||||
});
|
||||
txt = txt.replace(/#\w+;/g, function(s) {
|
||||
const innerTxt = s.substring(1, s.length - 1);
|
||||
const isInt = /^\+?\d+$/.test(innerTxt);
|
||||
if (isInt) {
|
||||
return "\uFB02\xB0\xB0" + innerTxt + "\xB6\xDF";
|
||||
} else {
|
||||
return "\uFB02\xB0" + innerTxt + "\xB6\xDF";
|
||||
}
|
||||
});
|
||||
return txt;
|
||||
}, "encodeEntities");
|
||||
var decodeEntities = /* @__PURE__ */ __name(function(text) {
|
||||
return text.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";");
|
||||
}, "decodeEntities");
|
||||
var getEdgeId = /* @__PURE__ */ __name((from, to, {
|
||||
counter = 0,
|
||||
prefix,
|
||||
suffix
|
||||
}, id) => {
|
||||
if (id) {
|
||||
return id;
|
||||
}
|
||||
return `${prefix ? `${prefix}_` : ""}${from}_${to}_${counter}${suffix ? `_${suffix}` : ""}`;
|
||||
}, "getEdgeId");
|
||||
function handleUndefinedAttr(attrValue) {
|
||||
return attrValue ?? null;
|
||||
}
|
||||
__name(handleUndefinedAttr, "handleUndefinedAttr");
|
||||
function isLabelCoordinateInPath(point, dAttr) {
|
||||
const roundedX = Math.round(point.x);
|
||||
const roundedY = Math.round(point.y);
|
||||
const sanitizedD = dAttr.replace(
|
||||
/(\d+\.\d+)/g,
|
||||
(match) => Math.round(parseFloat(match)).toString()
|
||||
);
|
||||
return sanitizedD.includes(roundedX.toString()) || sanitizedD.includes(roundedY.toString());
|
||||
}
|
||||
__name(isLabelCoordinateInPath, "isLabelCoordinateInPath");
|
||||
|
||||
export {
|
||||
ZERO_WIDTH_SPACE,
|
||||
removeDirectives,
|
||||
interpolateToCurve,
|
||||
getStylesFromArray,
|
||||
generateId,
|
||||
random,
|
||||
wrapLabel,
|
||||
calculateTextHeight,
|
||||
calculateTextWidth,
|
||||
isDetailedError,
|
||||
parseFontSize,
|
||||
cleanAndMerge,
|
||||
utils_default,
|
||||
encodeEntities,
|
||||
decodeEntities,
|
||||
getEdgeId,
|
||||
handleUndefinedAttr
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+2193
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+2716
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+54
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
CommonValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
PacketGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-FOC6F5B3.mjs
|
||||
var PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "PacketTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "PacketTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["packet"]);
|
||||
}
|
||||
};
|
||||
var PacketModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new PacketTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createPacketServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Packet = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
PacketGrammarGeneratedModule,
|
||||
PacketModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Packet);
|
||||
return { shared, Packet };
|
||||
}
|
||||
__name(createPacketServices, "createPacketServices");
|
||||
__name2(createPacketServices, "createPacketServices");
|
||||
|
||||
export {
|
||||
PacketModule,
|
||||
createPacketServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-FOC6F5B3.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n MermaidGeneratedSharedModule,\n PacketGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/packet/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/packet/tokenBuilder.ts\nvar PacketTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"PacketTokenBuilder\");\n }\n constructor() {\n super([\"packet\"]);\n }\n};\n\n// src/language/packet/module.ts\nvar PacketModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new PacketTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createPacketServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Packet = inject(\n createDefaultCoreModule({ shared }),\n PacketGrammarGeneratedModule,\n PacketModule\n );\n shared.ServiceRegistry.register(Packet);\n return { shared, Packet };\n}\n__name(createPacketServices, \"createPacketServices\");\n\nexport {\n PacketModule,\n createPacketServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,qBAAqB,cAAc,4BAA4B;AAAA,EAjBnE,OAiBmE;AAAA;AAAA;AAAA,EACjE,OAAO;AACL,IAAAA,QAAO,MAAM,oBAAoB;AAAA,EACnC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,QAAQ,CAAC;AAAA,EAClB;AACF;AAGA,IAAI,eAAe;AAAA,EACjB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,mBAAmB,GAAG,cAAc;AAAA,IACnF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,qBAAqB,UAAU,iBAAiB;AACvD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,SAAS;AAAA,IACb,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,MAAM;AACtC,SAAO,EAAE,QAAQ,OAAO;AAC1B;AAZS;AAaTA,QAAO,sBAAsB,sBAAsB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+138
@@ -0,0 +1,138 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
AbstractMermaidValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
TreemapGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-LIHQZDEY.mjs
|
||||
var TreemapTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "TreemapTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "TreemapTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["treemap"]);
|
||||
}
|
||||
};
|
||||
var classDefRegex = /classDef\s+([A-Z_a-z]\w+)(?:\s+([^\n\r;]*))?;?/;
|
||||
var TreemapValueConverter = class extends AbstractMermaidValueConverter {
|
||||
static {
|
||||
__name(this, "TreemapValueConverter");
|
||||
}
|
||||
static {
|
||||
__name2(this, "TreemapValueConverter");
|
||||
}
|
||||
runCustomConverter(rule, input, _cstNode) {
|
||||
if (rule.name === "NUMBER2") {
|
||||
return parseFloat(input.replace(/,/g, ""));
|
||||
} else if (rule.name === "SEPARATOR") {
|
||||
return input.substring(1, input.length - 1);
|
||||
} else if (rule.name === "STRING2") {
|
||||
return input.substring(1, input.length - 1);
|
||||
} else if (rule.name === "INDENTATION") {
|
||||
return input.length;
|
||||
} else if (rule.name === "ClassDef") {
|
||||
if (typeof input !== "string") {
|
||||
return input;
|
||||
}
|
||||
const match = classDefRegex.exec(input);
|
||||
if (match) {
|
||||
return {
|
||||
$type: "ClassDefStatement",
|
||||
className: match[1],
|
||||
styleText: match[2] || void 0
|
||||
};
|
||||
}
|
||||
}
|
||||
return void 0;
|
||||
}
|
||||
};
|
||||
function registerValidationChecks(services) {
|
||||
const validator = services.validation.TreemapValidator;
|
||||
const registry = services.validation.ValidationRegistry;
|
||||
if (registry) {
|
||||
const checks = {
|
||||
Treemap: validator.checkSingleRoot.bind(validator)
|
||||
// Remove unused validation for TreemapRow
|
||||
};
|
||||
registry.register(checks, validator);
|
||||
}
|
||||
}
|
||||
__name(registerValidationChecks, "registerValidationChecks");
|
||||
__name2(registerValidationChecks, "registerValidationChecks");
|
||||
var TreemapValidator = class {
|
||||
static {
|
||||
__name(this, "TreemapValidator");
|
||||
}
|
||||
static {
|
||||
__name2(this, "TreemapValidator");
|
||||
}
|
||||
/**
|
||||
* Validates that a treemap has only one root node.
|
||||
* A root node is defined as a node that has no indentation.
|
||||
*/
|
||||
checkSingleRoot(doc, accept) {
|
||||
let rootNodeIndentation;
|
||||
for (const row of doc.TreemapRows) {
|
||||
if (!row.item) {
|
||||
continue;
|
||||
}
|
||||
if (rootNodeIndentation === void 0 && // Check if this is a root node (no indentation)
|
||||
row.indent === void 0) {
|
||||
rootNodeIndentation = 0;
|
||||
} else if (row.indent === void 0) {
|
||||
accept("error", "Multiple root nodes are not allowed in a treemap.", {
|
||||
node: row,
|
||||
property: "item"
|
||||
});
|
||||
} else if (rootNodeIndentation !== void 0 && rootNodeIndentation >= parseInt(row.indent, 10)) {
|
||||
accept("error", "Multiple root nodes are not allowed in a treemap.", {
|
||||
node: row,
|
||||
property: "item"
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
var TreemapModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new TreemapTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new TreemapValueConverter(), "ValueConverter")
|
||||
},
|
||||
validation: {
|
||||
TreemapValidator: /* @__PURE__ */ __name2(() => new TreemapValidator(), "TreemapValidator")
|
||||
}
|
||||
};
|
||||
function createTreemapServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Treemap = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
TreemapGrammarGeneratedModule,
|
||||
TreemapModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Treemap);
|
||||
registerValidationChecks(Treemap);
|
||||
return { shared, Treemap };
|
||||
}
|
||||
__name(createTreemapServices, "createTreemapServices");
|
||||
__name2(createTreemapServices, "createTreemapServices");
|
||||
|
||||
export {
|
||||
TreemapModule,
|
||||
createTreemapServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-LIHQZDEY.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n TreemapGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/treemap/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/treemap/tokenBuilder.ts\nvar TreemapTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"TreemapTokenBuilder\");\n }\n constructor() {\n super([\"treemap\"]);\n }\n};\n\n// src/language/treemap/valueConverter.ts\nvar classDefRegex = /classDef\\s+([A-Z_a-z]\\w+)(?:\\s+([^\\n\\r;]*))?;?/;\nvar TreemapValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"TreemapValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name === \"NUMBER2\") {\n return parseFloat(input.replace(/,/g, \"\"));\n } else if (rule.name === \"SEPARATOR\") {\n return input.substring(1, input.length - 1);\n } else if (rule.name === \"STRING2\") {\n return input.substring(1, input.length - 1);\n } else if (rule.name === \"INDENTATION\") {\n return input.length;\n } else if (rule.name === \"ClassDef\") {\n if (typeof input !== \"string\") {\n return input;\n }\n const match = classDefRegex.exec(input);\n if (match) {\n return {\n $type: \"ClassDefStatement\",\n className: match[1],\n styleText: match[2] || void 0\n };\n }\n }\n return void 0;\n }\n};\n\n// src/language/treemap/treemap-validator.ts\nfunction registerValidationChecks(services) {\n const validator = services.validation.TreemapValidator;\n const registry = services.validation.ValidationRegistry;\n if (registry) {\n const checks = {\n Treemap: validator.checkSingleRoot.bind(validator)\n // Remove unused validation for TreemapRow\n };\n registry.register(checks, validator);\n }\n}\n__name(registerValidationChecks, \"registerValidationChecks\");\nvar TreemapValidator = class {\n static {\n __name(this, \"TreemapValidator\");\n }\n /**\n * Validates that a treemap has only one root node.\n * A root node is defined as a node that has no indentation.\n */\n checkSingleRoot(doc, accept) {\n let rootNodeIndentation;\n for (const row of doc.TreemapRows) {\n if (!row.item) {\n continue;\n }\n if (rootNodeIndentation === void 0 && // Check if this is a root node (no indentation)\n row.indent === void 0) {\n rootNodeIndentation = 0;\n } else if (row.indent === void 0) {\n accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n node: row,\n property: \"item\"\n });\n } else if (rootNodeIndentation !== void 0 && rootNodeIndentation >= parseInt(row.indent, 10)) {\n accept(\"error\", \"Multiple root nodes are not allowed in a treemap.\", {\n node: row,\n property: \"item\"\n });\n }\n }\n }\n};\n\n// src/language/treemap/module.ts\nvar TreemapModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new TreemapTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new TreemapValueConverter(), \"ValueConverter\")\n },\n validation: {\n TreemapValidator: /* @__PURE__ */ __name(() => new TreemapValidator(), \"TreemapValidator\")\n }\n};\nfunction createTreemapServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Treemap = inject(\n createDefaultCoreModule({ shared }),\n TreemapGrammarGeneratedModule,\n TreemapModule\n );\n shared.ServiceRegistry.register(Treemap);\n registerValidationChecks(Treemap);\n return { shared, Treemap };\n}\n__name(createTreemapServices, \"createTreemapServices\");\n\nexport {\n TreemapModule,\n createTreemapServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,sBAAsB,cAAc,4BAA4B;AAAA,EAjBpE,OAiBoE;AAAA;AAAA;AAAA,EAClE,OAAO;AACL,IAAAA,QAAO,MAAM,qBAAqB;AAAA,EACpC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,SAAS,CAAC;AAAA,EACnB;AACF;AAGA,IAAI,gBAAgB;AACpB,IAAI,wBAAwB,cAAc,8BAA8B;AAAA,EA5BxE,OA4BwE;AAAA;AAAA;AAAA,EACtE,OAAO;AACL,IAAAA,QAAO,MAAM,uBAAuB;AAAA,EACtC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,WAAW;AAC3B,aAAO,WAAW,MAAM,QAAQ,MAAM,EAAE,CAAC;AAAA,IAC3C,WAAW,KAAK,SAAS,aAAa;AACpC,aAAO,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC;AAAA,IAC5C,WAAW,KAAK,SAAS,WAAW;AAClC,aAAO,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC;AAAA,IAC5C,WAAW,KAAK,SAAS,eAAe;AACtC,aAAO,MAAM;AAAA,IACf,WAAW,KAAK,SAAS,YAAY;AACnC,UAAI,OAAO,UAAU,UAAU;AAC7B,eAAO;AAAA,MACT;AACA,YAAM,QAAQ,cAAc,KAAK,KAAK;AACtC,UAAI,OAAO;AACT,eAAO;AAAA,UACL,OAAO;AAAA,UACP,WAAW,MAAM,CAAC;AAAA,UAClB,WAAW,MAAM,CAAC,KAAK;AAAA,QACzB;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACF;AAGA,SAAS,yBAAyB,UAAU;AAC1C,QAAM,YAAY,SAAS,WAAW;AACtC,QAAM,WAAW,SAAS,WAAW;AACrC,MAAI,UAAU;AACZ,UAAM,SAAS;AAAA,MACb,SAAS,UAAU,gBAAgB,KAAK,SAAS;AAAA;AAAA,IAEnD;AACA,aAAS,SAAS,QAAQ,SAAS;AAAA,EACrC;AACF;AAVS;AAWTA,QAAO,0BAA0B,0BAA0B;AAC3D,IAAI,mBAAmB,MAAM;AAAA,EAvE7B,OAuE6B;AAAA;AAAA;AAAA,EAC3B,OAAO;AACL,IAAAA,QAAO,MAAM,kBAAkB;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB,KAAK,QAAQ;AAC3B,QAAI;AACJ,eAAW,OAAO,IAAI,aAAa;AACjC,UAAI,CAAC,IAAI,MAAM;AACb;AAAA,MACF;AACA,UAAI,wBAAwB;AAAA,MAC5B,IAAI,WAAW,QAAQ;AACrB,8BAAsB;AAAA,MACxB,WAAW,IAAI,WAAW,QAAQ;AAChC,eAAO,SAAS,qDAAqD;AAAA,UACnE,MAAM;AAAA,UACN,UAAU;AAAA,QACZ,CAAC;AAAA,MACH,WAAW,wBAAwB,UAAU,uBAAuB,SAAS,IAAI,QAAQ,EAAE,GAAG;AAC5F,eAAO,SAAS,qDAAqD;AAAA,UACnE,MAAM;AAAA,UACN,UAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF;AAGA,IAAI,gBAAgB;AAAA,EAClB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,oBAAoB,GAAG,cAAc;AAAA,IACpF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,sBAAsB,GAAG,gBAAgB;AAAA,EAC5F;AAAA,EACA,YAAY;AAAA,IACV,kBAAkC,gBAAAA,QAAO,MAAM,IAAI,iBAAiB,GAAG,kBAAkB;AAAA,EAC3F;AACF;AACA,SAAS,sBAAsB,UAAU,iBAAiB;AACxD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,UAAU;AAAA,IACd,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,OAAO;AACvC,2BAAyB,OAAO;AAChC,SAAO,EAAE,QAAQ,QAAQ;AAC3B;AAbS;AAcTA,QAAO,uBAAuB,uBAAuB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+2024
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+54
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
CommonValueConverter,
|
||||
EmptyFileSystem,
|
||||
InfoGrammarGeneratedModule,
|
||||
MermaidGeneratedSharedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-KGLVRYIC.mjs
|
||||
var InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "InfoTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "InfoTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["info", "showInfo"]);
|
||||
}
|
||||
};
|
||||
var InfoModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new InfoTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createInfoServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Info = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
InfoGrammarGeneratedModule,
|
||||
InfoModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Info);
|
||||
return { shared, Info };
|
||||
}
|
||||
__name(createInfoServices, "createInfoServices");
|
||||
__name2(createInfoServices, "createInfoServices");
|
||||
|
||||
export {
|
||||
InfoModule,
|
||||
createInfoServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-KGLVRYIC.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n InfoGrammarGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/info/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/info/tokenBuilder.ts\nvar InfoTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"InfoTokenBuilder\");\n }\n constructor() {\n super([\"info\", \"showInfo\"]);\n }\n};\n\n// src/language/info/module.ts\nvar InfoModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new InfoTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createInfoServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Info = inject(\n createDefaultCoreModule({ shared }),\n InfoGrammarGeneratedModule,\n InfoModule\n );\n shared.ServiceRegistry.register(Info);\n return { shared, Info };\n}\n__name(createInfoServices, \"createInfoServices\");\n\nexport {\n InfoModule,\n createInfoServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,mBAAmB,cAAc,4BAA4B;AAAA,EAjBjE,OAiBiE;AAAA;AAAA;AAAA,EAC/D,OAAO;AACL,IAAAA,QAAO,MAAM,kBAAkB;AAAA,EACjC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,QAAQ,UAAU,CAAC;AAAA,EAC5B;AACF;AAGA,IAAI,aAAa;AAAA,EACf,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,iBAAiB,GAAG,cAAc;AAAA,IACjF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,mBAAmB,UAAU,iBAAiB;AACrD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,OAAO;AAAA,IACX,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,IAAI;AACpC,SAAO,EAAE,QAAQ,KAAK;AACxB;AAZS;AAaTA,QAAO,oBAAoB,oBAAoB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+2055
File diff suppressed because one or more lines are too long
+7
File diff suppressed because one or more lines are too long
+5715
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+132
@@ -0,0 +1,132 @@
|
||||
import {
|
||||
require_dist
|
||||
} from "./chunk-3OTVAOVH.mjs";
|
||||
import {
|
||||
lineBreakRegex
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
select_default
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
__name,
|
||||
__toESM
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/common/svgDrawCommon.ts
|
||||
var import_sanitize_url = __toESM(require_dist(), 1);
|
||||
var drawRect = /* @__PURE__ */ __name((element, rectData) => {
|
||||
const rectElement = element.append("rect");
|
||||
rectElement.attr("x", rectData.x);
|
||||
rectElement.attr("y", rectData.y);
|
||||
rectElement.attr("fill", rectData.fill);
|
||||
rectElement.attr("stroke", rectData.stroke);
|
||||
rectElement.attr("width", rectData.width);
|
||||
rectElement.attr("height", rectData.height);
|
||||
if (rectData.name) {
|
||||
rectElement.attr("name", rectData.name);
|
||||
}
|
||||
if (rectData.rx) {
|
||||
rectElement.attr("rx", rectData.rx);
|
||||
}
|
||||
if (rectData.ry) {
|
||||
rectElement.attr("ry", rectData.ry);
|
||||
}
|
||||
if (rectData.attrs !== void 0) {
|
||||
for (const attrKey in rectData.attrs) {
|
||||
rectElement.attr(attrKey, rectData.attrs[attrKey]);
|
||||
}
|
||||
}
|
||||
if (rectData.class) {
|
||||
rectElement.attr("class", rectData.class);
|
||||
}
|
||||
return rectElement;
|
||||
}, "drawRect");
|
||||
var drawBackgroundRect = /* @__PURE__ */ __name((element, bounds) => {
|
||||
const rectData = {
|
||||
x: bounds.startx,
|
||||
y: bounds.starty,
|
||||
width: bounds.stopx - bounds.startx,
|
||||
height: bounds.stopy - bounds.starty,
|
||||
fill: bounds.fill,
|
||||
stroke: bounds.stroke,
|
||||
class: "rect"
|
||||
};
|
||||
const rectElement = drawRect(element, rectData);
|
||||
rectElement.lower();
|
||||
}, "drawBackgroundRect");
|
||||
var drawText = /* @__PURE__ */ __name((element, textData) => {
|
||||
const nText = textData.text.replace(lineBreakRegex, " ");
|
||||
const textElem = element.append("text");
|
||||
textElem.attr("x", textData.x);
|
||||
textElem.attr("y", textData.y);
|
||||
textElem.attr("class", "legend");
|
||||
textElem.style("text-anchor", textData.anchor);
|
||||
if (textData.class) {
|
||||
textElem.attr("class", textData.class);
|
||||
}
|
||||
const tspan = textElem.append("tspan");
|
||||
tspan.attr("x", textData.x + textData.textMargin * 2);
|
||||
tspan.text(nText);
|
||||
return textElem;
|
||||
}, "drawText");
|
||||
var drawImage = /* @__PURE__ */ __name((elem, x, y, link) => {
|
||||
const imageElement = elem.append("image");
|
||||
imageElement.attr("x", x);
|
||||
imageElement.attr("y", y);
|
||||
const sanitizedLink = (0, import_sanitize_url.sanitizeUrl)(link);
|
||||
imageElement.attr("xlink:href", sanitizedLink);
|
||||
}, "drawImage");
|
||||
var drawEmbeddedImage = /* @__PURE__ */ __name((element, x, y, link) => {
|
||||
const imageElement = element.append("use");
|
||||
imageElement.attr("x", x);
|
||||
imageElement.attr("y", y);
|
||||
const sanitizedLink = (0, import_sanitize_url.sanitizeUrl)(link);
|
||||
imageElement.attr("xlink:href", `#${sanitizedLink}`);
|
||||
}, "drawEmbeddedImage");
|
||||
var getNoteRect = /* @__PURE__ */ __name(() => {
|
||||
const noteRectData = {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: 100,
|
||||
height: 100,
|
||||
fill: "#EDF2AE",
|
||||
stroke: "#666",
|
||||
anchor: "start",
|
||||
rx: 0,
|
||||
ry: 0
|
||||
};
|
||||
return noteRectData;
|
||||
}, "getNoteRect");
|
||||
var getTextObj = /* @__PURE__ */ __name(() => {
|
||||
const testObject = {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: 100,
|
||||
height: 100,
|
||||
"text-anchor": "start",
|
||||
style: "#666",
|
||||
textMargin: 0,
|
||||
rx: 0,
|
||||
ry: 0,
|
||||
tspan: true
|
||||
};
|
||||
return testObject;
|
||||
}, "getTextObj");
|
||||
var createTooltip = /* @__PURE__ */ __name(() => {
|
||||
let tooltipElem = select_default(".mermaidTooltip");
|
||||
if (tooltipElem.empty()) {
|
||||
tooltipElem = select_default("body").append("div").attr("class", "mermaidTooltip").style("opacity", 0).style("position", "absolute").style("text-align", "center").style("max-width", "200px").style("padding", "2px").style("font-size", "12px").style("background", "#ffffde").style("border", "1px solid #333").style("border-radius", "2px").style("pointer-events", "none").style("z-index", "100");
|
||||
}
|
||||
return tooltipElem;
|
||||
}, "createTooltip");
|
||||
|
||||
export {
|
||||
drawRect,
|
||||
drawBackgroundRect,
|
||||
drawText,
|
||||
drawImage,
|
||||
drawEmbeddedImage,
|
||||
getNoteRect,
|
||||
getTextObj,
|
||||
createTooltip
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/diagrams/common/svgDrawCommon.ts"],
|
||||
"sourcesContent": ["import { sanitizeUrl } from '@braintree/sanitize-url';\nimport { select } from 'd3';\nimport type { SVG, SVGGroup } from '../../diagram-api/types.js';\nimport { lineBreakRegex } from './common.js';\nimport type {\n Bound,\n D3ImageElement,\n D3RectElement,\n D3TSpanElement,\n D3TextElement,\n D3UseElement,\n RectData,\n TextData,\n TextObject,\n} from './commonTypes.js';\n\nexport const drawRect = (element: SVG | SVGGroup, rectData: RectData): D3RectElement => {\n const rectElement: D3RectElement = element.append('rect');\n rectElement.attr('x', rectData.x);\n rectElement.attr('y', rectData.y);\n rectElement.attr('fill', rectData.fill);\n rectElement.attr('stroke', rectData.stroke);\n rectElement.attr('width', rectData.width);\n rectElement.attr('height', rectData.height);\n if (rectData.name) {\n rectElement.attr('name', rectData.name);\n }\n if (rectData.rx) {\n rectElement.attr('rx', rectData.rx);\n }\n if (rectData.ry) {\n rectElement.attr('ry', rectData.ry);\n }\n\n if (rectData.attrs !== undefined) {\n for (const attrKey in rectData.attrs) {\n rectElement.attr(attrKey, rectData.attrs[attrKey]);\n }\n }\n\n if (rectData.class) {\n rectElement.attr('class', rectData.class);\n }\n\n return rectElement;\n};\n\n/**\n * Draws a background rectangle\n *\n * @param element - Diagram (reference for bounds)\n * @param bounds - Shape of the rectangle\n */\nexport const drawBackgroundRect = (element: SVG | SVGGroup, bounds: Bound): void => {\n const rectData: RectData = {\n x: bounds.startx,\n y: bounds.starty,\n width: bounds.stopx - bounds.startx,\n height: bounds.stopy - bounds.starty,\n fill: bounds.fill,\n stroke: bounds.stroke,\n class: 'rect',\n };\n const rectElement: D3RectElement = drawRect(element, rectData);\n rectElement.lower();\n};\n\nexport const drawText = (element: SVG | SVGGroup, textData: TextData): D3TextElement => {\n const nText: string = textData.text.replace(lineBreakRegex, ' ');\n\n const textElem: D3TextElement = element.append('text');\n textElem.attr('x', textData.x);\n textElem.attr('y', textData.y);\n textElem.attr('class', 'legend');\n\n textElem.style('text-anchor', textData.anchor);\n if (textData.class) {\n textElem.attr('class', textData.class);\n }\n\n const tspan: D3TSpanElement = textElem.append('tspan');\n tspan.attr('x', textData.x + textData.textMargin * 2);\n tspan.text(nText);\n\n return textElem;\n};\n\nexport const drawImage = (elem: SVG | SVGGroup, x: number, y: number, link: string): void => {\n const imageElement: D3ImageElement = elem.append('image');\n imageElement.attr('x', x);\n imageElement.attr('y', y);\n const sanitizedLink: string = sanitizeUrl(link);\n imageElement.attr('xlink:href', sanitizedLink);\n};\n\nexport const drawEmbeddedImage = (\n element: SVG | SVGGroup,\n x: number,\n y: number,\n link: string\n): void => {\n const imageElement: D3UseElement = element.append('use');\n imageElement.attr('x', x);\n imageElement.attr('y', y);\n const sanitizedLink: string = sanitizeUrl(link);\n imageElement.attr('xlink:href', `#${sanitizedLink}`);\n};\n\nexport const getNoteRect = (): RectData => {\n const noteRectData: RectData = {\n x: 0,\n y: 0,\n width: 100,\n height: 100,\n fill: '#EDF2AE',\n stroke: '#666',\n anchor: 'start',\n rx: 0,\n ry: 0,\n };\n return noteRectData;\n};\n\nexport const getTextObj = (): TextObject => {\n const testObject: TextObject = {\n x: 0,\n y: 0,\n width: 100,\n height: 100,\n 'text-anchor': 'start',\n style: '#666',\n textMargin: 0,\n rx: 0,\n ry: 0,\n tspan: true,\n };\n return testObject;\n};\n\nexport const createTooltip = () => {\n let tooltipElem = select<HTMLDivElement, unknown>('.mermaidTooltip');\n if (tooltipElem.empty()) {\n tooltipElem = select('body')\n .append('div')\n .attr('class', 'mermaidTooltip')\n .style('opacity', 0)\n .style('position', 'absolute')\n .style('text-align', 'center')\n .style('max-width', '200px')\n .style('padding', '2px')\n .style('font-size', '12px')\n .style('background', '#ffffde')\n .style('border', '1px solid #333')\n .style('border-radius', '2px')\n .style('pointer-events', 'none')\n .style('z-index', '100');\n }\n return tooltipElem;\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;AAAA,0BAA4B;AAgBrB,IAAM,WAAW,wBAAC,SAAyB,aAAsC;AACtF,QAAM,cAA6B,QAAQ,OAAO,MAAM;AACxD,cAAY,KAAK,KAAK,SAAS,CAAC;AAChC,cAAY,KAAK,KAAK,SAAS,CAAC;AAChC,cAAY,KAAK,QAAQ,SAAS,IAAI;AACtC,cAAY,KAAK,UAAU,SAAS,MAAM;AAC1C,cAAY,KAAK,SAAS,SAAS,KAAK;AACxC,cAAY,KAAK,UAAU,SAAS,MAAM;AAC1C,MAAI,SAAS,MAAM;AACjB,gBAAY,KAAK,QAAQ,SAAS,IAAI;AAAA,EACxC;AACA,MAAI,SAAS,IAAI;AACf,gBAAY,KAAK,MAAM,SAAS,EAAE;AAAA,EACpC;AACA,MAAI,SAAS,IAAI;AACf,gBAAY,KAAK,MAAM,SAAS,EAAE;AAAA,EACpC;AAEA,MAAI,SAAS,UAAU,QAAW;AAChC,eAAW,WAAW,SAAS,OAAO;AACpC,kBAAY,KAAK,SAAS,SAAS,MAAM,OAAO,CAAC;AAAA,IACnD;AAAA,EACF;AAEA,MAAI,SAAS,OAAO;AAClB,gBAAY,KAAK,SAAS,SAAS,KAAK;AAAA,EAC1C;AAEA,SAAO;AACT,GA7BwB;AAqCjB,IAAM,qBAAqB,wBAAC,SAAyB,WAAwB;AAClF,QAAM,WAAqB;AAAA,IACzB,GAAG,OAAO;AAAA,IACV,GAAG,OAAO;AAAA,IACV,OAAO,OAAO,QAAQ,OAAO;AAAA,IAC7B,QAAQ,OAAO,QAAQ,OAAO;AAAA,IAC9B,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,OAAO;AAAA,EACT;AACA,QAAM,cAA6B,SAAS,SAAS,QAAQ;AAC7D,cAAY,MAAM;AACpB,GAZkC;AAc3B,IAAM,WAAW,wBAAC,SAAyB,aAAsC;AACtF,QAAM,QAAgB,SAAS,KAAK,QAAQ,gBAAgB,GAAG;AAE/D,QAAM,WAA0B,QAAQ,OAAO,MAAM;AACrD,WAAS,KAAK,KAAK,SAAS,CAAC;AAC7B,WAAS,KAAK,KAAK,SAAS,CAAC;AAC7B,WAAS,KAAK,SAAS,QAAQ;AAE/B,WAAS,MAAM,eAAe,SAAS,MAAM;AAC7C,MAAI,SAAS,OAAO;AAClB,aAAS,KAAK,SAAS,SAAS,KAAK;AAAA,EACvC;AAEA,QAAM,QAAwB,SAAS,OAAO,OAAO;AACrD,QAAM,KAAK,KAAK,SAAS,IAAI,SAAS,aAAa,CAAC;AACpD,QAAM,KAAK,KAAK;AAEhB,SAAO;AACT,GAlBwB;AAoBjB,IAAM,YAAY,wBAAC,MAAsB,GAAW,GAAW,SAAuB;AAC3F,QAAM,eAA+B,KAAK,OAAO,OAAO;AACxD,eAAa,KAAK,KAAK,CAAC;AACxB,eAAa,KAAK,KAAK,CAAC;AACxB,QAAM,oBAAwB,iCAAY,IAAI;AAC9C,eAAa,KAAK,cAAc,aAAa;AAC/C,GANyB;AAQlB,IAAM,oBAAoB,wBAC/B,SACA,GACA,GACA,SACS;AACT,QAAM,eAA6B,QAAQ,OAAO,KAAK;AACvD,eAAa,KAAK,KAAK,CAAC;AACxB,eAAa,KAAK,KAAK,CAAC;AACxB,QAAM,oBAAwB,iCAAY,IAAI;AAC9C,eAAa,KAAK,cAAc,IAAI,aAAa,EAAE;AACrD,GAXiC;AAa1B,IAAM,cAAc,6BAAgB;AACzC,QAAM,eAAyB;AAAA,IAC7B,GAAG;AAAA,IACH,GAAG;AAAA,IACH,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,IAAI;AAAA,IACJ,IAAI;AAAA,EACN;AACA,SAAO;AACT,GAb2B;AAepB,IAAM,aAAa,6BAAkB;AAC1C,QAAM,aAAyB;AAAA,IAC7B,GAAG;AAAA,IACH,GAAG;AAAA,IACH,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,eAAe;AAAA,IACf,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,OAAO;AAAA,EACT;AACA,SAAO;AACT,GAd0B;AAgBnB,IAAM,gBAAgB,6BAAM;AACjC,MAAI,cAAc,eAAgC,iBAAiB;AACnE,MAAI,YAAY,MAAM,GAAG;AACvB,kBAAc,eAAO,MAAM,EACxB,OAAO,KAAK,EACZ,KAAK,SAAS,gBAAgB,EAC9B,MAAM,WAAW,CAAC,EAClB,MAAM,YAAY,UAAU,EAC5B,MAAM,cAAc,QAAQ,EAC5B,MAAM,aAAa,OAAO,EAC1B,MAAM,WAAW,KAAK,EACtB,MAAM,aAAa,MAAM,EACzB,MAAM,cAAc,SAAS,EAC7B,MAAM,UAAU,gBAAgB,EAChC,MAAM,iBAAiB,KAAK,EAC5B,MAAM,kBAAkB,MAAM,EAC9B,MAAM,WAAW,KAAK;AAAA,EAC3B;AACA,SAAO;AACT,GAnB6B;",
|
||||
"names": []
|
||||
}
|
||||
+99
@@ -0,0 +1,99 @@
|
||||
import {
|
||||
__name as __name2
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/mermaid-parser.core.mjs
|
||||
var parsers = {};
|
||||
var initializers = {
|
||||
info: /* @__PURE__ */ __name2(async () => {
|
||||
const { createInfoServices: createInfoServices2 } = await import("./info-OMHHGYJF-5WKMRTR7.mjs");
|
||||
const parser = createInfoServices2().Info.parser.LangiumParser;
|
||||
parsers.info = parser;
|
||||
}, "info"),
|
||||
packet: /* @__PURE__ */ __name2(async () => {
|
||||
const { createPacketServices: createPacketServices2 } = await import("./packet-4T2RLAQJ-KIAKHBGY.mjs");
|
||||
const parser = createPacketServices2().Packet.parser.LangiumParser;
|
||||
parsers.packet = parser;
|
||||
}, "packet"),
|
||||
pie: /* @__PURE__ */ __name2(async () => {
|
||||
const { createPieServices: createPieServices2 } = await import("./pie-ZZUOXDRM-DHM77I3D.mjs");
|
||||
const parser = createPieServices2().Pie.parser.LangiumParser;
|
||||
parsers.pie = parser;
|
||||
}, "pie"),
|
||||
treeView: /* @__PURE__ */ __name2(async () => {
|
||||
const { createTreeViewServices: createTreeViewServices2 } = await import("./treeView-SZITEDCU-XYQEM24W.mjs");
|
||||
const parser = createTreeViewServices2().TreeView.parser.LangiumParser;
|
||||
parsers.treeView = parser;
|
||||
}, "treeView"),
|
||||
architecture: /* @__PURE__ */ __name2(async () => {
|
||||
const { createArchitectureServices: createArchitectureServices2 } = await import("./architecture-YZFGNWBL-SHOFS5JC.mjs");
|
||||
const parser = createArchitectureServices2().Architecture.parser.LangiumParser;
|
||||
parsers.architecture = parser;
|
||||
}, "architecture"),
|
||||
gitGraph: /* @__PURE__ */ __name2(async () => {
|
||||
const { createGitGraphServices: createGitGraphServices2 } = await import("./gitGraph-7Q5UKJZL-OZ6BR2NM.mjs");
|
||||
const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;
|
||||
parsers.gitGraph = parser;
|
||||
}, "gitGraph"),
|
||||
radar: /* @__PURE__ */ __name2(async () => {
|
||||
const { createRadarServices: createRadarServices2 } = await import("./radar-PYXPWWZC-LLCHBXKI.mjs");
|
||||
const parser = createRadarServices2().Radar.parser.LangiumParser;
|
||||
parsers.radar = parser;
|
||||
}, "radar"),
|
||||
treemap: /* @__PURE__ */ __name2(async () => {
|
||||
const { createTreemapServices: createTreemapServices2 } = await import("./treemap-W4RFUUIX-TFP7P7ZZ.mjs");
|
||||
const parser = createTreemapServices2().Treemap.parser.LangiumParser;
|
||||
parsers.treemap = parser;
|
||||
}, "treemap"),
|
||||
wardley: /* @__PURE__ */ __name2(async () => {
|
||||
const { createWardleyServices: createWardleyServices2 } = await import("./wardley-RL74JXVD-T2LBEBUU.mjs");
|
||||
const parser = createWardleyServices2().Wardley.parser.LangiumParser;
|
||||
parsers.wardley = parser;
|
||||
}, "wardley")
|
||||
};
|
||||
async function parse(diagramType, text) {
|
||||
const initializer = initializers[diagramType];
|
||||
if (!initializer) {
|
||||
throw new Error(`Unknown diagram type: ${diagramType}`);
|
||||
}
|
||||
if (!parsers[diagramType]) {
|
||||
await initializer();
|
||||
}
|
||||
const parser = parsers[diagramType];
|
||||
const result = parser.parse(text);
|
||||
if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
|
||||
throw new MermaidParseError(result);
|
||||
}
|
||||
return result.value;
|
||||
}
|
||||
__name(parse, "parse");
|
||||
__name2(parse, "parse");
|
||||
var MermaidParseError = class extends Error {
|
||||
static {
|
||||
__name(this, "MermaidParseError");
|
||||
}
|
||||
constructor(result) {
|
||||
const lexerErrors = result.lexerErrors.map((err) => {
|
||||
const line = err.line !== void 0 && !isNaN(err.line) ? err.line : "?";
|
||||
const column = err.column !== void 0 && !isNaN(err.column) ? err.column : "?";
|
||||
return `Lexer error on line ${line}, column ${column}: ${err.message}`;
|
||||
}).join("\n");
|
||||
const parserErrors = result.parserErrors.map((err) => {
|
||||
const line = err.token.startLine !== void 0 && !isNaN(err.token.startLine) ? err.token.startLine : "?";
|
||||
const column = err.token.startColumn !== void 0 && !isNaN(err.token.startColumn) ? err.token.startColumn : "?";
|
||||
return `Parse error on line ${line}, column ${column}: ${err.message}`;
|
||||
}).join("\n");
|
||||
super(`Parsing failed: ${lexerErrors} ${parserErrors}`);
|
||||
this.result = result;
|
||||
}
|
||||
static {
|
||||
__name2(this, "MermaidParseError");
|
||||
}
|
||||
};
|
||||
|
||||
export {
|
||||
parse
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+1085
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+2053
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+68
@@ -0,0 +1,68 @@
|
||||
import {
|
||||
parseFontSize
|
||||
} from "./chunk-5FJ6MPNB.mjs";
|
||||
import {
|
||||
defaultConfig_default,
|
||||
getConfig2 as getConfig
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/utils/subGraphTitleMargins.ts
|
||||
var getSubGraphTitleMargins = /* @__PURE__ */ __name(({
|
||||
flowchart
|
||||
}) => {
|
||||
const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0;
|
||||
const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0;
|
||||
const subGraphTitleTotalMargin = subGraphTitleTopMargin + subGraphTitleBottomMargin;
|
||||
return {
|
||||
subGraphTitleTopMargin,
|
||||
subGraphTitleBottomMargin,
|
||||
subGraphTitleTotalMargin
|
||||
};
|
||||
}, "getSubGraphTitleMargins");
|
||||
|
||||
// src/rendering-util/rendering-elements/shapes/labelImageUtils.ts
|
||||
async function configureLabelImages(container, labelText) {
|
||||
const images = container.getElementsByTagName("img");
|
||||
if (!images || images.length === 0) {
|
||||
return;
|
||||
}
|
||||
const noImgText = labelText.replace(/<img[^>]*>/g, "").trim() === "";
|
||||
await Promise.all(
|
||||
[...images].map(
|
||||
(img) => new Promise((res) => {
|
||||
function setupImage() {
|
||||
img.style.display = "flex";
|
||||
img.style.flexDirection = "column";
|
||||
if (noImgText) {
|
||||
const bodyFontSize = getConfig().fontSize ? getConfig().fontSize : window.getComputedStyle(document.body).fontSize;
|
||||
const enlargingFactor = 5;
|
||||
const [parsedBodyFontSize = defaultConfig_default.fontSize] = parseFontSize(bodyFontSize);
|
||||
const width = parsedBodyFontSize * enlargingFactor + "px";
|
||||
img.style.minWidth = width;
|
||||
img.style.maxWidth = width;
|
||||
} else {
|
||||
img.style.width = "100%";
|
||||
}
|
||||
res(img);
|
||||
}
|
||||
__name(setupImage, "setupImage");
|
||||
setTimeout(() => {
|
||||
if (img.complete) {
|
||||
setupImage();
|
||||
}
|
||||
});
|
||||
img.addEventListener("error", setupImage);
|
||||
img.addEventListener("load", setupImage);
|
||||
})
|
||||
)
|
||||
);
|
||||
}
|
||||
__name(configureLabelImages, "configureLabelImages");
|
||||
|
||||
export {
|
||||
configureLabelImages,
|
||||
getSubGraphTitleMargins
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/utils/subGraphTitleMargins.ts", "../../../src/rendering-util/rendering-elements/shapes/labelImageUtils.ts"],
|
||||
"sourcesContent": ["import type { FlowchartDiagramConfig } from '../config.type.js';\n\nexport const getSubGraphTitleMargins = ({\n flowchart,\n}: {\n flowchart: FlowchartDiagramConfig;\n}): {\n subGraphTitleTopMargin: number;\n subGraphTitleBottomMargin: number;\n subGraphTitleTotalMargin: number;\n} => {\n const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0;\n const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0;\n const subGraphTitleTotalMargin = subGraphTitleTopMargin + subGraphTitleBottomMargin;\n\n return {\n subGraphTitleTopMargin,\n subGraphTitleBottomMargin,\n subGraphTitleTotalMargin,\n };\n};\n", "import { getConfig } from '../../../diagram-api/diagramAPI.js';\nimport defaultConfig from '../../../defaultConfig.js';\nimport { parseFontSize } from '../../../utils.js';\n\n/**\n * Waits for all images in a container to load and applies appropriate styling.\n * This ensures accurate bounding box measurements after images are loaded.\n *\n * @param container - The HTML element containing img tags\n * @param labelText - The original label text to check if there's text besides images\n * @returns Promise that resolves when all images are loaded and styled\n */\nexport async function configureLabelImages(\n container: HTMLElement,\n labelText: string\n): Promise<void> {\n const images = container.getElementsByTagName('img');\n if (!images || images.length === 0) {\n return;\n }\n\n const noImgText = labelText.replace(/<img[^>]*>/g, '').trim() === '';\n\n await Promise.all(\n [...images].map(\n (img) =>\n new Promise((res) => {\n function setupImage() {\n img.style.display = 'flex';\n img.style.flexDirection = 'column';\n\n if (noImgText) {\n // default size if no text\n const bodyFontSize = getConfig().fontSize\n ? getConfig().fontSize\n : window.getComputedStyle(document.body).fontSize;\n const enlargingFactor = 5;\n const [parsedBodyFontSize = defaultConfig.fontSize] = parseFontSize(bodyFontSize);\n const width = parsedBodyFontSize * enlargingFactor + 'px';\n img.style.minWidth = width;\n img.style.maxWidth = width;\n } else {\n img.style.width = '100%';\n }\n res(img);\n }\n setTimeout(() => {\n if (img.complete) {\n setupImage();\n }\n });\n img.addEventListener('error', setupImage);\n img.addEventListener('load', setupImage);\n })\n )\n );\n}\n"],
|
||||
"mappings": ";;;;;;;;;;;;AAEO,IAAM,0BAA0B,wBAAC;AAAA,EACtC;AACF,MAMK;AACH,QAAM,yBAAyB,WAAW,qBAAqB,OAAO;AACtE,QAAM,4BAA4B,WAAW,qBAAqB,UAAU;AAC5E,QAAM,2BAA2B,yBAAyB;AAE1D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF,GAlBuC;;;ACUvC,eAAsB,qBACpB,WACA,WACe;AACf,QAAM,SAAS,UAAU,qBAAqB,KAAK;AACnD,MAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC;AAAA,EACF;AAEA,QAAM,YAAY,UAAU,QAAQ,eAAe,EAAE,EAAE,KAAK,MAAM;AAElE,QAAM,QAAQ;AAAA,IACZ,CAAC,GAAG,MAAM,EAAE;AAAA,MACV,CAAC,QACC,IAAI,QAAQ,CAAC,QAAQ;AACnB,iBAAS,aAAa;AACpB,cAAI,MAAM,UAAU;AACpB,cAAI,MAAM,gBAAgB;AAE1B,cAAI,WAAW;AAEb,kBAAM,eAAe,UAAU,EAAE,WAC7B,UAAU,EAAE,WACZ,OAAO,iBAAiB,SAAS,IAAI,EAAE;AAC3C,kBAAM,kBAAkB;AACxB,kBAAM,CAAC,qBAAqB,sBAAc,QAAQ,IAAI,cAAc,YAAY;AAChF,kBAAM,QAAQ,qBAAqB,kBAAkB;AACrD,gBAAI,MAAM,WAAW;AACrB,gBAAI,MAAM,WAAW;AAAA,UACvB,OAAO;AACL,gBAAI,MAAM,QAAQ;AAAA,UACpB;AACA,cAAI,GAAG;AAAA,QACT;AAlBS;AAmBT,mBAAW,MAAM;AACf,cAAI,IAAI,UAAU;AAChB,uBAAW;AAAA,UACb;AAAA,QACF,CAAC;AACD,YAAI,iBAAiB,SAAS,UAAU;AACxC,YAAI,iBAAiB,QAAQ,UAAU;AAAA,MACzC,CAAC;AAAA,IACL;AAAA,EACF;AACF;AA5CsB;",
|
||||
"names": []
|
||||
}
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
import {
|
||||
configureSvgSize
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
log
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/rendering-util/setupViewPortForSVG.ts
|
||||
var setupViewPortForSVG = /* @__PURE__ */ __name((svg, padding, cssDiagram, useMaxWidth) => {
|
||||
svg.attr("class", cssDiagram);
|
||||
const { width, height, x, y } = calculateDimensionsWithPadding(svg, padding);
|
||||
configureSvgSize(svg, height, width, useMaxWidth);
|
||||
const viewBox = createViewBox(x, y, width, height, padding);
|
||||
svg.attr("viewBox", viewBox);
|
||||
log.debug(`viewBox configured: ${viewBox} with padding: ${padding}`);
|
||||
}, "setupViewPortForSVG");
|
||||
var calculateDimensionsWithPadding = /* @__PURE__ */ __name((svg, padding) => {
|
||||
const bounds = svg.node()?.getBBox() || { width: 0, height: 0, x: 0, y: 0 };
|
||||
return {
|
||||
width: bounds.width + padding * 2,
|
||||
height: bounds.height + padding * 2,
|
||||
x: bounds.x,
|
||||
y: bounds.y
|
||||
};
|
||||
}, "calculateDimensionsWithPadding");
|
||||
var createViewBox = /* @__PURE__ */ __name((x, y, width, height, padding) => {
|
||||
return `${x - padding} ${y - padding} ${width} ${height}`;
|
||||
}, "createViewBox");
|
||||
|
||||
export {
|
||||
setupViewPortForSVG
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/rendering-util/setupViewPortForSVG.ts"],
|
||||
"sourcesContent": ["import { configureSvgSize } from '../setupGraphViewbox.js';\nimport type { SVG } from '../diagram-api/types.js';\nimport { log } from '../logger.js';\n\nexport const setupViewPortForSVG = (\n svg: SVG,\n padding: number,\n cssDiagram: string,\n useMaxWidth: boolean\n) => {\n // Initialize the SVG element and set the diagram class\n svg.attr('class', cssDiagram);\n\n // Calculate the dimensions and position with padding\n const { width, height, x, y } = calculateDimensionsWithPadding(svg, padding);\n\n // Configure the size and aspect ratio of the SVG\n configureSvgSize(svg, height, width, useMaxWidth);\n\n // Update the viewBox to ensure all content is visible with padding\n const viewBox = createViewBox(x, y, width, height, padding);\n svg.attr('viewBox', viewBox);\n\n // Log the viewBox configuration for debugging\n log.debug(`viewBox configured: ${viewBox} with padding: ${padding}`);\n};\n\nconst calculateDimensionsWithPadding = (svg: SVG, padding: number) => {\n const bounds = svg.node()?.getBBox() || { width: 0, height: 0, x: 0, y: 0 };\n return {\n width: bounds.width + padding * 2,\n height: bounds.height + padding * 2,\n x: bounds.x,\n y: bounds.y,\n };\n};\n\nconst createViewBox = (x: number, y: number, width: number, height: number, padding: number) => {\n return `${x - padding} ${y - padding} ${width} ${height}`;\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;AAIO,IAAM,sBAAsB,wBACjC,KACA,SACA,YACA,gBACG;AAEH,MAAI,KAAK,SAAS,UAAU;AAG5B,QAAM,EAAE,OAAO,QAAQ,GAAG,EAAE,IAAI,+BAA+B,KAAK,OAAO;AAG3E,mBAAiB,KAAK,QAAQ,OAAO,WAAW;AAGhD,QAAM,UAAU,cAAc,GAAG,GAAG,OAAO,QAAQ,OAAO;AAC1D,MAAI,KAAK,WAAW,OAAO;AAG3B,MAAI,MAAM,uBAAuB,OAAO,kBAAkB,OAAO,EAAE;AACrE,GArBmC;AAuBnC,IAAM,iCAAiC,wBAAC,KAAU,YAAoB;AACpE,QAAM,SAAS,IAAI,KAAK,GAAG,QAAQ,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,GAAG,GAAG,GAAG,EAAE;AAC1E,SAAO;AAAA,IACL,OAAO,OAAO,QAAQ,UAAU;AAAA,IAChC,QAAQ,OAAO,SAAS,UAAU;AAAA,IAClC,GAAG,OAAO;AAAA,IACV,GAAG,OAAO;AAAA,EACZ;AACF,GARuC;AAUvC,IAAM,gBAAgB,wBAAC,GAAW,GAAW,OAAe,QAAgB,YAAoB;AAC9F,SAAO,GAAG,IAAI,OAAO,IAAI,IAAI,OAAO,IAAI,KAAK,IAAI,MAAM;AACzD,GAFsB;",
|
||||
"names": []
|
||||
}
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
import {
|
||||
AbstractMermaidValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
WardleyGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-CIAEETIT.mjs
|
||||
var WardleyValueConverter = class extends AbstractMermaidValueConverter {
|
||||
static {
|
||||
__name(this, "WardleyValueConverter");
|
||||
}
|
||||
static {
|
||||
__name2(this, "WardleyValueConverter");
|
||||
}
|
||||
runCustomConverter(rule, input, _cstNode) {
|
||||
switch (rule.name.toUpperCase()) {
|
||||
case "LINK_LABEL":
|
||||
return input.substring(1).trim();
|
||||
default:
|
||||
return void 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
var WardleyModule = {
|
||||
parser: {
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new WardleyValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createWardleyServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Wardley = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
WardleyGrammarGeneratedModule,
|
||||
WardleyModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Wardley);
|
||||
return { shared, Wardley };
|
||||
}
|
||||
__name(createWardleyServices, "createWardleyServices");
|
||||
__name2(createWardleyServices, "createWardleyServices");
|
||||
|
||||
export {
|
||||
WardleyModule,
|
||||
createWardleyServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-CIAEETIT.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n WardleyGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/wardley/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/wardley/valueConverter.ts\nvar WardleyValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"WardleyValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n switch (rule.name.toUpperCase()) {\n case \"LINK_LABEL\":\n return input.substring(1).trim();\n default:\n return void 0;\n }\n }\n};\n\n// src/language/wardley/module.ts\nvar WardleyModule = {\n parser: {\n ValueConverter: /* @__PURE__ */ __name(() => new WardleyValueConverter(), \"ValueConverter\")\n }\n};\nfunction createWardleyServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Wardley = inject(\n createDefaultCoreModule({ shared }),\n WardleyGrammarGeneratedModule,\n WardleyModule\n );\n shared.ServiceRegistry.register(Wardley);\n return { shared, Wardley };\n}\n__name(createWardleyServices, \"createWardleyServices\");\n\nexport {\n WardleyModule,\n createWardleyServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;AAgBA,IAAI,wBAAwB,cAAc,8BAA8B;AAAA,EAhBxE,OAgBwE;AAAA;AAAA;AAAA,EACtE,OAAO;AACL,IAAAA,QAAO,MAAM,uBAAuB;AAAA,EACtC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,YAAQ,KAAK,KAAK,YAAY,GAAG;AAAA,MAC/B,KAAK;AACH,eAAO,MAAM,UAAU,CAAC,EAAE,KAAK;AAAA,MACjC;AACE,eAAO;AAAA,IACX;AAAA,EACF;AACF;AAGA,IAAI,gBAAgB;AAAA,EAClB,QAAQ;AAAA,IACN,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,sBAAsB,GAAG,gBAAgB;AAAA,EAC5F;AACF;AACA,SAAS,sBAAsB,UAAU,iBAAiB;AACxD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,UAAU;AAAA,IACd,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,OAAO;AACvC,SAAO,EAAE,QAAQ,QAAQ;AAC3B;AAZS;AAaTA,QAAO,uBAAuB,uBAAuB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
||||
var __esm = (fn, res) => function __init() {
|
||||
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
||||
};
|
||||
var __commonJS = (cb, mod) => function __require() {
|
||||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||||
};
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
|
||||
export {
|
||||
__name,
|
||||
__esm,
|
||||
__commonJS,
|
||||
__export,
|
||||
__reExport,
|
||||
__toESM,
|
||||
__toCommonJS
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": [],
|
||||
"sourcesContent": [],
|
||||
"mappings": "",
|
||||
"names": []
|
||||
}
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
import {
|
||||
insertEdge,
|
||||
insertEdgeLabel,
|
||||
markers_default,
|
||||
positionEdgeLabel
|
||||
} from "./chunk-3ENLOZB5.mjs";
|
||||
import {
|
||||
insertCluster,
|
||||
insertNode,
|
||||
labelHelper
|
||||
} from "./chunk-C7LX3TON.mjs";
|
||||
import {
|
||||
interpolateToCurve
|
||||
} from "./chunk-5FJ6MPNB.mjs";
|
||||
import {
|
||||
common_default,
|
||||
getConfig
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
log
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/internals.ts
|
||||
var internalHelpers = {
|
||||
common: common_default,
|
||||
getConfig,
|
||||
insertCluster,
|
||||
insertEdge,
|
||||
insertEdgeLabel,
|
||||
insertMarkers: markers_default,
|
||||
insertNode,
|
||||
interpolateToCurve,
|
||||
labelHelper,
|
||||
log,
|
||||
positionEdgeLabel
|
||||
};
|
||||
|
||||
// src/rendering-util/render.ts
|
||||
var layoutAlgorithms = {};
|
||||
var registerLayoutLoaders = /* @__PURE__ */ __name((loaders) => {
|
||||
for (const loader of loaders) {
|
||||
layoutAlgorithms[loader.name] = loader;
|
||||
}
|
||||
}, "registerLayoutLoaders");
|
||||
var registerDefaultLayoutLoaders = /* @__PURE__ */ __name(() => {
|
||||
registerLayoutLoaders([
|
||||
{
|
||||
name: "dagre",
|
||||
loader: /* @__PURE__ */ __name(async () => await import("./dagre-F7A4LSFC.mjs"), "loader")
|
||||
},
|
||||
...true ? [
|
||||
{
|
||||
name: "cose-bilkent",
|
||||
loader: /* @__PURE__ */ __name(async () => await import("./cose-bilkent-MPYRLQ2G.mjs"), "loader")
|
||||
}
|
||||
] : []
|
||||
]);
|
||||
}, "registerDefaultLayoutLoaders");
|
||||
registerDefaultLayoutLoaders();
|
||||
var render = /* @__PURE__ */ __name(async (data4Layout, svg) => {
|
||||
if (!(data4Layout.layoutAlgorithm in layoutAlgorithms)) {
|
||||
throw new Error(`Unknown layout algorithm: ${data4Layout.layoutAlgorithm}`);
|
||||
}
|
||||
if (data4Layout.diagramId) {
|
||||
for (const node of data4Layout.nodes) {
|
||||
const originalDomId = node.domId || node.id;
|
||||
node.domId = `${data4Layout.diagramId}-${originalDomId}`;
|
||||
}
|
||||
}
|
||||
const layoutDefinition = layoutAlgorithms[data4Layout.layoutAlgorithm];
|
||||
const layoutRenderer = await layoutDefinition.loader();
|
||||
const { theme, themeVariables } = data4Layout.config;
|
||||
const { useGradient, gradientStart, gradientStop } = themeVariables;
|
||||
const svgId = svg.attr("id");
|
||||
svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow`).attr("height", "130%").attr("width", "130%").append("feDropShadow").attr("dx", "4").attr("dy", "4").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
|
||||
svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow-small`).attr("height", "150%").attr("width", "150%").append("feDropShadow").attr("dx", "2").attr("dy", "2").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
|
||||
if (useGradient) {
|
||||
const gradient = svg.append("linearGradient").attr("id", svg.attr("id") + "-gradient").attr("gradientUnits", "objectBoundingBox").attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%");
|
||||
gradient.append("svg:stop").attr("offset", "0%").attr("stop-color", gradientStart).attr("stop-opacity", 1);
|
||||
gradient.append("svg:stop").attr("offset", "100%").attr("stop-color", gradientStop).attr("stop-opacity", 1);
|
||||
}
|
||||
return layoutRenderer.render(data4Layout, svg, internalHelpers, {
|
||||
algorithm: layoutDefinition.algorithm
|
||||
});
|
||||
}, "render");
|
||||
var getRegisteredLayoutAlgorithm = /* @__PURE__ */ __name((algorithm = "", { fallback = "dagre" } = {}) => {
|
||||
if (algorithm in layoutAlgorithms) {
|
||||
return algorithm;
|
||||
}
|
||||
if (fallback in layoutAlgorithms) {
|
||||
log.warn(`Layout algorithm ${algorithm} is not registered. Using ${fallback} as fallback.`);
|
||||
return fallback;
|
||||
}
|
||||
throw new Error(`Both layout algorithms ${algorithm} and ${fallback} are not registered.`);
|
||||
}, "getRegisteredLayoutAlgorithm");
|
||||
|
||||
export {
|
||||
registerLayoutLoaders,
|
||||
render,
|
||||
getRegisteredLayoutAlgorithm
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+6948
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+807
@@ -0,0 +1,807 @@
|
||||
import {
|
||||
filter_default,
|
||||
forEach_default,
|
||||
isUndefined_default,
|
||||
keys_default,
|
||||
reduce_default,
|
||||
union_default,
|
||||
values_default
|
||||
} from "./chunk-MFRUYFWM.mjs";
|
||||
import {
|
||||
isEmpty_default
|
||||
} from "./chunk-UKL4YMJ2.mjs";
|
||||
import {
|
||||
constant_default,
|
||||
isFunction_default
|
||||
} from "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/graph.js
|
||||
var DEFAULT_EDGE_NAME = "\0";
|
||||
var GRAPH_NODE = "\0";
|
||||
var EDGE_KEY_DELIM = "";
|
||||
var Graph = class {
|
||||
static {
|
||||
__name(this, "Graph");
|
||||
}
|
||||
/**
|
||||
* @param {GraphOptions} [opts] - Graph options.
|
||||
*/
|
||||
constructor(opts = {}) {
|
||||
this._isDirected = Object.prototype.hasOwnProperty.call(opts, "directed") ? opts.directed : true;
|
||||
this._isMultigraph = Object.prototype.hasOwnProperty.call(opts, "multigraph") ? opts.multigraph : false;
|
||||
this._isCompound = Object.prototype.hasOwnProperty.call(opts, "compound") ? opts.compound : false;
|
||||
this._label = void 0;
|
||||
this._defaultNodeLabelFn = constant_default(void 0);
|
||||
this._defaultEdgeLabelFn = constant_default(void 0);
|
||||
this._nodes = {};
|
||||
if (this._isCompound) {
|
||||
this._parent = {};
|
||||
this._children = {};
|
||||
this._children[GRAPH_NODE] = {};
|
||||
}
|
||||
this._in = {};
|
||||
this._preds = {};
|
||||
this._out = {};
|
||||
this._sucs = {};
|
||||
this._edgeObjs = {};
|
||||
this._edgeLabels = {};
|
||||
}
|
||||
/* === Graph functions ========= */
|
||||
/**
|
||||
*
|
||||
* @returns {boolean} `true` if the graph is [directed](https://en.wikipedia.org/wiki/Directed_graph).
|
||||
* A directed graph treats the order of nodes in an edge as significant whereas an
|
||||
* [undirected](https://en.wikipedia.org/wiki/Graph_(mathematics)#Undirected_graph)
|
||||
* graph does not.
|
||||
* This example demonstrates the difference:
|
||||
*
|
||||
* @example
|
||||
*
|
||||
* ```js
|
||||
* var directed = new Graph({ directed: true });
|
||||
* directed.setEdge("a", "b", "my-label");
|
||||
* directed.edge("a", "b"); // returns "my-label"
|
||||
* directed.edge("b", "a"); // returns undefined
|
||||
*
|
||||
* var undirected = new Graph({ directed: false });
|
||||
* undirected.setEdge("a", "b", "my-label");
|
||||
* undirected.edge("a", "b"); // returns "my-label"
|
||||
* undirected.edge("b", "a"); // returns "my-label"
|
||||
* ```
|
||||
*/
|
||||
isDirected() {
|
||||
return this._isDirected;
|
||||
}
|
||||
/**
|
||||
* @returns {boolean} `true` if the graph is a multigraph.
|
||||
*/
|
||||
isMultigraph() {
|
||||
return this._isMultigraph;
|
||||
}
|
||||
/**
|
||||
* @returns {boolean} `true` if the graph is compound.
|
||||
*/
|
||||
isCompound() {
|
||||
return this._isCompound;
|
||||
}
|
||||
/**
|
||||
* Sets the label for the graph to `label`.
|
||||
*
|
||||
* @param {GraphLabel} label - Label for the graph.
|
||||
* @returns {this}
|
||||
*/
|
||||
setGraph(label) {
|
||||
this._label = label;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* @returns {GraphLabel | undefined} the currently assigned label for the graph.
|
||||
* If no label has been assigned, returns `undefined`.
|
||||
*
|
||||
* @example
|
||||
*
|
||||
* ```js
|
||||
* var g = new Graph();
|
||||
* g.graph(); // returns undefined
|
||||
* g.setGraph("graph-label");
|
||||
* g.graph(); // returns "graph-label"
|
||||
* ```
|
||||
*/
|
||||
graph() {
|
||||
return this._label;
|
||||
}
|
||||
/* === Node functions ========== */
|
||||
/**
|
||||
* Sets a new default value that is assigned to nodes that are created without
|
||||
* a label.
|
||||
*
|
||||
* @param {typeof this._defaultNodeLabelFn | NodeLabel} newDefault - If a function,
|
||||
* it is called with the id of the node being created.
|
||||
* Otherwise, it is assigned as the label directly.
|
||||
* @returns {this}
|
||||
*/
|
||||
setDefaultNodeLabel(newDefault) {
|
||||
if (!isFunction_default(newDefault)) {
|
||||
newDefault = constant_default(newDefault);
|
||||
}
|
||||
this._defaultNodeLabelFn = newDefault;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* @returns {number} the number of nodes in the graph.
|
||||
*/
|
||||
nodeCount() {
|
||||
return this._nodeCount;
|
||||
}
|
||||
/**
|
||||
* @returns {NodeID[]} the ids of the nodes in the graph.
|
||||
*
|
||||
* @remarks
|
||||
* Use {@link node()} to get the label for each node.
|
||||
* Takes `O(|V|)` time.
|
||||
*/
|
||||
nodes() {
|
||||
return keys_default(this._nodes);
|
||||
}
|
||||
/**
|
||||
* @returns {NodeID[]} those nodes in the graph that have no in-edges.
|
||||
* @remarks Takes `O(|V|)` time.
|
||||
*/
|
||||
sources() {
|
||||
var self = this;
|
||||
return filter_default(this.nodes(), function(v) {
|
||||
return isEmpty_default(self._in[v]);
|
||||
});
|
||||
}
|
||||
/**
|
||||
* @returns {NodeID[]} those nodes in the graph that have no out-edges.
|
||||
* @remarks Takes `O(|V|)` time.
|
||||
*/
|
||||
sinks() {
|
||||
var self = this;
|
||||
return filter_default(this.nodes(), function(v) {
|
||||
return isEmpty_default(self._out[v]);
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Invokes setNode method for each node in `vs` list.
|
||||
*
|
||||
* @param {Collection<NodeID | number>} vs - List of node IDs to create/set.
|
||||
* @param {NodeLabel} [value] - If set, update all nodes with this value.
|
||||
* @returns {this}
|
||||
* @remarks Complexity: O(|names|).
|
||||
*/
|
||||
setNodes(vs, value) {
|
||||
var args = arguments;
|
||||
var self = this;
|
||||
forEach_default(vs, function(v) {
|
||||
if (args.length > 1) {
|
||||
self.setNode(v, value);
|
||||
} else {
|
||||
self.setNode(v);
|
||||
}
|
||||
});
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Creates or updates the value for the node `v` in the graph.
|
||||
*
|
||||
* @param {NodeID | number} v - ID of the node to create/set.
|
||||
* @param {NodeLabel} [value] - If supplied, it is set as the value for the node.
|
||||
* If not supplied and the node was created by this call then
|
||||
* {@link setDefaultNodeLabel} will be used to set the node's value.
|
||||
* @returns {this} the graph, allowing this to be chained with other functions.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
setNode(v, value) {
|
||||
if (Object.prototype.hasOwnProperty.call(this._nodes, v)) {
|
||||
if (arguments.length > 1) {
|
||||
this._nodes[v] = value;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
|
||||
if (this._isCompound) {
|
||||
this._parent[v] = GRAPH_NODE;
|
||||
this._children[v] = {};
|
||||
this._children[GRAPH_NODE][v] = true;
|
||||
}
|
||||
this._in[v] = {};
|
||||
this._preds[v] = {};
|
||||
this._out[v] = {};
|
||||
this._sucs[v] = {};
|
||||
++this._nodeCount;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Gets the label of node with specified name.
|
||||
*
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {NodeLabel | undefined} the label assigned to the node with the id `v`
|
||||
* if it is in the graph.
|
||||
* Otherwise returns `undefined`.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
node(v) {
|
||||
return this._nodes[v];
|
||||
}
|
||||
/**
|
||||
* Detects whether graph has a node with specified name or not.
|
||||
*
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {boolean} Returns `true` the graph has a node with the id.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
hasNode(v) {
|
||||
return Object.prototype.hasOwnProperty.call(this._nodes, v);
|
||||
}
|
||||
/**
|
||||
* Remove the node with the id `v` in the graph or do nothing if the node is
|
||||
* not in the graph.
|
||||
*
|
||||
* If the node was removed this function also removes any incident edges.
|
||||
*
|
||||
* @param {NodeID | number} v - Node ID to remove.
|
||||
* @returns {this} the graph, allowing this to be chained with other functions.
|
||||
* @remarks Takes `O(|E|)` time.
|
||||
*/
|
||||
removeNode(v) {
|
||||
if (Object.prototype.hasOwnProperty.call(this._nodes, v)) {
|
||||
var removeEdge = /* @__PURE__ */ __name((e) => this.removeEdge(this._edgeObjs[e]), "removeEdge");
|
||||
delete this._nodes[v];
|
||||
if (this._isCompound) {
|
||||
this._removeFromParentsChildList(v);
|
||||
delete this._parent[v];
|
||||
forEach_default(this.children(v), (child) => {
|
||||
this.setParent(child);
|
||||
});
|
||||
delete this._children[v];
|
||||
}
|
||||
forEach_default(keys_default(this._in[v]), removeEdge);
|
||||
delete this._in[v];
|
||||
delete this._preds[v];
|
||||
forEach_default(keys_default(this._out[v]), removeEdge);
|
||||
delete this._out[v];
|
||||
delete this._sucs[v];
|
||||
--this._nodeCount;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Sets the parent for `v` to `parent` if it is defined or removes the parent
|
||||
* for `v` if `parent` is undefined.
|
||||
*
|
||||
* @param {NodeID | number} v - Node ID to set the parent for.
|
||||
* @param {NodeID | number} [parent] - Parent node ID. If not defined, removes the parent.
|
||||
* @returns {this} the graph, allowing this to be chained with other functions.
|
||||
* @throws if the graph is not compound.
|
||||
* @throws if setting the parent would create a cycle.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
setParent(v, parent) {
|
||||
if (!this._isCompound) {
|
||||
throw new Error("Cannot set parent in a non-compound graph");
|
||||
}
|
||||
if (isUndefined_default(parent)) {
|
||||
parent = GRAPH_NODE;
|
||||
} else {
|
||||
parent += "";
|
||||
for (var ancestor = parent; !isUndefined_default(ancestor); ancestor = this.parent(ancestor)) {
|
||||
if (ancestor === v) {
|
||||
throw new Error("Setting " + parent + " as parent of " + v + " would create a cycle");
|
||||
}
|
||||
}
|
||||
this.setNode(parent);
|
||||
}
|
||||
this.setNode(v);
|
||||
this._removeFromParentsChildList(v);
|
||||
this._parent[v] = parent;
|
||||
this._children[parent][v] = true;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* @private
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
*/
|
||||
_removeFromParentsChildList(v) {
|
||||
delete this._children[this._parent[v]][v];
|
||||
}
|
||||
/**
|
||||
* Get parent node for node `v`.
|
||||
*
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {NodeID | undefined} the node that is a parent of node `v`
|
||||
* or `undefined` if node `v` does not have a parent or is not a member of
|
||||
* the graph.
|
||||
* Always returns `undefined` for graphs that are not compound.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
parent(v) {
|
||||
if (this._isCompound) {
|
||||
var parent = this._parent[v];
|
||||
if (parent !== GRAPH_NODE) {
|
||||
return parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Gets list of direct children of node v.
|
||||
*
|
||||
* @param {NodeID | number} [v] - Node ID. If not specified, gets nodes
|
||||
* with no parent (top-level nodes).
|
||||
* @returns {NodeID[] | undefined} all nodes that are children of node `v` or
|
||||
* `undefined` if node `v` is not in the graph.
|
||||
* Always returns `[]` for graphs that are not compound.
|
||||
* @remarks Takes `O(|V|)` time.
|
||||
*/
|
||||
children(v) {
|
||||
if (isUndefined_default(v)) {
|
||||
v = GRAPH_NODE;
|
||||
}
|
||||
if (this._isCompound) {
|
||||
var children = this._children[v];
|
||||
if (children) {
|
||||
return keys_default(children);
|
||||
}
|
||||
} else if (v === GRAPH_NODE) {
|
||||
return this.nodes();
|
||||
} else if (this.hasNode(v)) {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {NodeID[] | undefined} all nodes that are predecessors of the
|
||||
* specified node or `undefined` if node `v` is not in the graph.
|
||||
* @remarks
|
||||
* Behavior is undefined for undirected graphs - use {@link neighbors} instead.
|
||||
* Takes `O(|V|)` time.
|
||||
*/
|
||||
predecessors(v) {
|
||||
var predsV = this._preds[v];
|
||||
if (predsV) {
|
||||
return keys_default(predsV);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {NodeID[] | undefined} all nodes that are successors of the
|
||||
* specified node or `undefined` if node `v` is not in the graph.
|
||||
* @remarks
|
||||
* Behavior is undefined for undirected graphs - use {@link neighbors} instead.
|
||||
* Takes `O(|V|)` time.
|
||||
*/
|
||||
successors(v) {
|
||||
var sucsV = this._sucs[v];
|
||||
if (sucsV) {
|
||||
return keys_default(sucsV);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {NodeID[] | undefined} all nodes that are predecessors or
|
||||
* successors of the specified node
|
||||
* or `undefined` if node `v` is not in the graph.
|
||||
* @remarks Takes `O(|V|)` time.
|
||||
*/
|
||||
neighbors(v) {
|
||||
var preds = this.predecessors(v);
|
||||
if (preds) {
|
||||
return union_default(preds, this.successors(v));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Node ID.
|
||||
* @returns {boolean} True if the node is a leaf (has no successors), false otherwise.
|
||||
*/
|
||||
isLeaf(v) {
|
||||
var neighbors;
|
||||
if (this.isDirected()) {
|
||||
neighbors = this.successors(v);
|
||||
} else {
|
||||
neighbors = this.neighbors(v);
|
||||
}
|
||||
return neighbors.length === 0;
|
||||
}
|
||||
/**
|
||||
* Creates new graph with nodes filtered via `filter`.
|
||||
* Edges incident to rejected node
|
||||
* are also removed.
|
||||
*
|
||||
* In case of compound graph, if parent is rejected by `filter`,
|
||||
* than all its children are rejected too.
|
||||
|
||||
* @param {(v: NodeID) => boolean} filter - Function that returns `true` for nodes to keep.
|
||||
* @returns {Graph<GraphLabel, NodeLabel, EdgeLabel>} A new graph containing only the nodes for which `filter` returns `true`.
|
||||
* @remarks Average-case complexity: O(|E|+|V|).
|
||||
*/
|
||||
filterNodes(filter) {
|
||||
var copy = new this.constructor({
|
||||
directed: this._isDirected,
|
||||
multigraph: this._isMultigraph,
|
||||
compound: this._isCompound
|
||||
});
|
||||
copy.setGraph(this.graph());
|
||||
var self = this;
|
||||
forEach_default(this._nodes, function(value, v) {
|
||||
if (filter(v)) {
|
||||
copy.setNode(v, value);
|
||||
}
|
||||
});
|
||||
forEach_default(this._edgeObjs, function(e) {
|
||||
if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
|
||||
copy.setEdge(e, self.edge(e));
|
||||
}
|
||||
});
|
||||
var parents = {};
|
||||
function findParent(v) {
|
||||
var parent = self.parent(v);
|
||||
if (parent === void 0 || copy.hasNode(parent)) {
|
||||
parents[v] = parent;
|
||||
return parent;
|
||||
} else if (parent in parents) {
|
||||
return parents[parent];
|
||||
} else {
|
||||
return findParent(parent);
|
||||
}
|
||||
}
|
||||
__name(findParent, "findParent");
|
||||
if (this._isCompound) {
|
||||
forEach_default(copy.nodes(), function(v) {
|
||||
copy.setParent(v, findParent(v));
|
||||
});
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
/* === Edge functions ========== */
|
||||
/**
|
||||
* Sets a new default value that is assigned to edges that are created without
|
||||
* a label.
|
||||
*
|
||||
* @param {typeof this._defaultEdgeLabelFn | EdgeLabel} newDefault - If a function,
|
||||
* it is called with the parameters `(v, w, name)`.
|
||||
* Otherwise, it is assigned as the label directly.
|
||||
* @returns {this}
|
||||
*/
|
||||
setDefaultEdgeLabel(newDefault) {
|
||||
if (!isFunction_default(newDefault)) {
|
||||
newDefault = constant_default(newDefault);
|
||||
}
|
||||
this._defaultEdgeLabelFn = newDefault;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* @returns {number} the number of edges in the graph.
|
||||
* @remarks Complexity: O(1).
|
||||
*/
|
||||
edgeCount() {
|
||||
return this._edgeCount;
|
||||
}
|
||||
/**
|
||||
* Gets edges of the graph.
|
||||
*
|
||||
* @returns {EdgeObj[]} the {@link EdgeObj} for each edge in the graph.
|
||||
*
|
||||
* @remarks
|
||||
* In case of compound graph subgraphs are not considered.
|
||||
* Use {@link edge()} to get the label for each edge.
|
||||
* Takes `O(|E|)` time.
|
||||
*/
|
||||
edges() {
|
||||
return values_default(this._edgeObjs);
|
||||
}
|
||||
/**
|
||||
* Establish an edges path over the nodes in nodes list.
|
||||
*
|
||||
* If some edge is already exists, it will update its label, otherwise it will
|
||||
* create an edge between pair of nodes with label provided or default label
|
||||
* if no label provided.
|
||||
*
|
||||
* @param {Collection<NodeID>} vs - List of node IDs to create edges between.
|
||||
* @param {EdgeLabel} [value] - If set, update all edges with this value.
|
||||
* @returns {this}
|
||||
* @remarks Complexity: O(|nodes|).
|
||||
*/
|
||||
setPath(vs, value) {
|
||||
var self = this;
|
||||
var args = arguments;
|
||||
reduce_default(vs, function(v, w) {
|
||||
if (args.length > 1) {
|
||||
self.setEdge(v, w, value);
|
||||
} else {
|
||||
self.setEdge(v, w);
|
||||
}
|
||||
return w;
|
||||
});
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Creates or updates the label for the edge (`v`, `w`) with the optionally
|
||||
* supplied `name`.
|
||||
*
|
||||
* @overload
|
||||
* @param {EdgeObj} arg0 - Edge object.
|
||||
* @param {EdgeLabel} [value] - If supplied, it is set as the label for the edge.
|
||||
* If not supplied and the edge was created by this call then
|
||||
* {@link setDefaultEdgeLabel} will be used to assign the edge's label.
|
||||
* @returns {this} the graph, allowing this to be chained with other functions.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
/**
|
||||
* Creates or updates the label for the edge (`v`, `w`) with the optionally
|
||||
* supplied `name`.
|
||||
*
|
||||
* @overload
|
||||
* @param {NodeID | number} v - Source node ID. Number values will be coerced to strings.
|
||||
* @param {NodeID | number} w - Target node ID. Number values will be coerced to strings.
|
||||
* @param {EdgeLabel} [value] - If supplied, it is set as the label for the edge.
|
||||
* If not supplied and the edge was created by this call then
|
||||
* {@link setDefaultEdgeLabel} will be used to assign the edge's label.
|
||||
* @param {string | number} [name] - Edge name. Only useful with multigraphs.
|
||||
* @returns {this} the graph, allowing this to be chained with other functions.
|
||||
* @remarks Takes `O(1)` time.
|
||||
*/
|
||||
setEdge() {
|
||||
var v, w, name, value;
|
||||
var valueSpecified = false;
|
||||
var arg0 = arguments[0];
|
||||
if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
|
||||
v = arg0.v;
|
||||
w = arg0.w;
|
||||
name = arg0.name;
|
||||
if (arguments.length === 2) {
|
||||
value = arguments[1];
|
||||
valueSpecified = true;
|
||||
}
|
||||
} else {
|
||||
v = arg0;
|
||||
w = arguments[1];
|
||||
name = arguments[3];
|
||||
if (arguments.length > 2) {
|
||||
value = arguments[2];
|
||||
valueSpecified = true;
|
||||
}
|
||||
}
|
||||
v = "" + v;
|
||||
w = "" + w;
|
||||
if (!isUndefined_default(name)) {
|
||||
name = "" + name;
|
||||
}
|
||||
var e = edgeArgsToId(this._isDirected, v, w, name);
|
||||
if (Object.prototype.hasOwnProperty.call(this._edgeLabels, e)) {
|
||||
if (valueSpecified) {
|
||||
this._edgeLabels[e] = value;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
if (!isUndefined_default(name) && !this._isMultigraph) {
|
||||
throw new Error("Cannot set a named edge when isMultigraph = false");
|
||||
}
|
||||
this.setNode(v);
|
||||
this.setNode(w);
|
||||
this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
|
||||
var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
|
||||
v = edgeObj.v;
|
||||
w = edgeObj.w;
|
||||
Object.freeze(edgeObj);
|
||||
this._edgeObjs[e] = edgeObj;
|
||||
incrementOrInitEntry(this._preds[w], v);
|
||||
incrementOrInitEntry(this._sucs[v], w);
|
||||
this._in[w][e] = edgeObj;
|
||||
this._out[v][e] = edgeObj;
|
||||
this._edgeCount++;
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Gets the label for the specified edge.
|
||||
*
|
||||
* @overload
|
||||
* @param {EdgeObj} v - Edge object.
|
||||
* @returns {EdgeLabel | undefined} the label for the edge (`v`, `w`) if the
|
||||
* graph has an edge between `v` and `w` with the optional `name`.
|
||||
* Returned `undefined` if there is no such edge in the graph.
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
/**
|
||||
* Gets the label for the specified edge.
|
||||
*
|
||||
* @overload
|
||||
* @param {NodeID | number} v - Source node ID.
|
||||
* @param {NodeID | number} w - Target node ID.
|
||||
* @param {string | number} [name] - Edge name. Only useful with multigraphs.
|
||||
* @returns {EdgeLabel | undefined} the label for the edge (`v`, `w`) if the
|
||||
* graph has an edge between `v` and `w` with the optional `name`.
|
||||
* Returned `undefined` if there is no such edge in the graph.
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
edge(v, w, name) {
|
||||
var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
|
||||
return this._edgeLabels[e];
|
||||
}
|
||||
/**
|
||||
* Detects whether the graph contains specified edge or not.
|
||||
*
|
||||
* @overload
|
||||
* @param {EdgeObj} v - Edge object.
|
||||
* @returns {boolean} `true` if the graph has an edge between `v` and `w`
|
||||
* with the optional `name`.
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* No subgraphs are considered.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
/**
|
||||
* Detects whether the graph contains specified edge or not.
|
||||
*
|
||||
* @overload
|
||||
* @param {NodeID | number} v - Source node ID.
|
||||
* @param {NodeID | number} w - Target node ID.
|
||||
* @param {string | number} [name] - Edge name. Only useful with multigraphs.
|
||||
* @returns {boolean} `true` if the graph has an edge between `v` and `w`
|
||||
* with the optional `name`.
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* No subgraphs are considered.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
hasEdge(v, w, name) {
|
||||
var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
|
||||
return Object.prototype.hasOwnProperty.call(this._edgeLabels, e);
|
||||
}
|
||||
/**
|
||||
* Removes the edge (`v`, `w`) if the graph has an edge between `v` and `w`
|
||||
* with the optional `name`. If not this function does nothing.
|
||||
*
|
||||
* @overload
|
||||
* @param {EdgeObj} v - Edge object.
|
||||
* @returns {this}
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* No subgraphs are considered.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
/**
|
||||
* Removes the edge (`v`, `w`) if the graph has an edge between `v` and `w`
|
||||
* with the optional `name`. If not this function does nothing.
|
||||
*
|
||||
* @overload
|
||||
* @param {NodeID | number} v - Source node ID.
|
||||
* @param {NodeID | number} w - Target node ID.
|
||||
* @param {string | number} [name] - Edge name. Only useful with multigraphs.
|
||||
* @returns {this}
|
||||
* @remarks
|
||||
* `v` and `w` can be interchanged for undirected graphs.
|
||||
* Takes `O(1)` time.
|
||||
*/
|
||||
removeEdge(v, w, name) {
|
||||
var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
|
||||
var edge = this._edgeObjs[e];
|
||||
if (edge) {
|
||||
v = edge.v;
|
||||
w = edge.w;
|
||||
delete this._edgeLabels[e];
|
||||
delete this._edgeObjs[e];
|
||||
decrementOrRemoveEntry(this._preds[w], v);
|
||||
decrementOrRemoveEntry(this._sucs[v], w);
|
||||
delete this._in[w][e];
|
||||
delete this._out[v][e];
|
||||
this._edgeCount--;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Target node ID.
|
||||
* @param {NodeID | number} [u] - Optionally filters edges down to just those
|
||||
* coming from node `u`.
|
||||
* @returns {EdgeObj[] | undefined} all edges that point to the node `v`.
|
||||
* Returns `undefined` if node `v` is not in the graph.
|
||||
* @remarks
|
||||
* Behavior is undefined for undirected graphs - use {@link nodeEdges} instead.
|
||||
* Takes `O(|E|)` time.
|
||||
*/
|
||||
inEdges(v, u) {
|
||||
var inV = this._in[v];
|
||||
if (inV) {
|
||||
var edges = values_default(inV);
|
||||
if (!u) {
|
||||
return edges;
|
||||
}
|
||||
return filter_default(edges, function(edge) {
|
||||
return edge.v === u;
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Target node ID.
|
||||
* @param {NodeID | number} [w] - Optionally filters edges down to just those
|
||||
* that point to `w`.
|
||||
* @returns {EdgeObj[] | undefined} all edges that point to the node `v`.
|
||||
* Returns `undefined` if node `v` is not in the graph.
|
||||
* @remarks
|
||||
* Behavior is undefined for undirected graphs - use {@link nodeEdges} instead.
|
||||
* Takes `O(|E|)` time.
|
||||
*/
|
||||
outEdges(v, w) {
|
||||
var outV = this._out[v];
|
||||
if (outV) {
|
||||
var edges = values_default(outV);
|
||||
if (!w) {
|
||||
return edges;
|
||||
}
|
||||
return filter_default(edges, function(edge) {
|
||||
return edge.w === w;
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param {NodeID | number} v - Target Node ID.
|
||||
* @param {NodeID | number} [w] - If set, filters those edges down to just
|
||||
* those between nodes `v` and `w` regardless of direction
|
||||
* @returns {EdgeObj[] | undefined} all edges to or from node `v` regardless
|
||||
* of direction. Returns `undefined` if node `v` is not in the graph.
|
||||
* @remarks Takes `O(|E|)` time.
|
||||
*/
|
||||
nodeEdges(v, w) {
|
||||
var inEdges = this.inEdges(v, w);
|
||||
if (inEdges) {
|
||||
return inEdges.concat(this.outEdges(v, w));
|
||||
}
|
||||
}
|
||||
};
|
||||
Graph.prototype._nodeCount = 0;
|
||||
Graph.prototype._edgeCount = 0;
|
||||
function incrementOrInitEntry(map, k) {
|
||||
if (map[k]) {
|
||||
map[k]++;
|
||||
} else {
|
||||
map[k] = 1;
|
||||
}
|
||||
}
|
||||
__name(incrementOrInitEntry, "incrementOrInitEntry");
|
||||
function decrementOrRemoveEntry(map, k) {
|
||||
if (!--map[k]) {
|
||||
delete map[k];
|
||||
}
|
||||
}
|
||||
__name(decrementOrRemoveEntry, "decrementOrRemoveEntry");
|
||||
function edgeArgsToId(isDirected, v_, w_, name) {
|
||||
var v = "" + v_;
|
||||
var w = "" + w_;
|
||||
if (!isDirected && v > w) {
|
||||
var tmp = v;
|
||||
v = w;
|
||||
w = tmp;
|
||||
}
|
||||
return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (isUndefined_default(name) ? DEFAULT_EDGE_NAME : name);
|
||||
}
|
||||
__name(edgeArgsToId, "edgeArgsToId");
|
||||
function edgeArgsToObj(isDirected, v_, w_, name) {
|
||||
var v = "" + v_;
|
||||
var w = "" + w_;
|
||||
if (!isDirected && v > w) {
|
||||
var tmp = v;
|
||||
v = w;
|
||||
w = tmp;
|
||||
}
|
||||
var edgeObj = { v, w };
|
||||
if (name) {
|
||||
edgeObj.name = name;
|
||||
}
|
||||
return edgeObj;
|
||||
}
|
||||
__name(edgeArgsToObj, "edgeArgsToObj");
|
||||
function edgeObjToId(isDirected, edgeObj) {
|
||||
return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
|
||||
}
|
||||
__name(edgeObjToId, "edgeObjToId");
|
||||
|
||||
export {
|
||||
Graph
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+24
@@ -0,0 +1,24 @@
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/utils/imperativeState.ts
|
||||
var ImperativeState = class {
|
||||
/**
|
||||
* @param init - Function that creates the default state.
|
||||
*/
|
||||
constructor(init) {
|
||||
this.init = init;
|
||||
this.records = this.init();
|
||||
}
|
||||
static {
|
||||
__name(this, "ImperativeState");
|
||||
}
|
||||
reset() {
|
||||
this.records = this.init();
|
||||
}
|
||||
};
|
||||
|
||||
export {
|
||||
ImperativeState
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/utils/imperativeState.ts"],
|
||||
"sourcesContent": ["/**\n * Resettable state storage.\n * @example\n * ```\n * const state = new ImperativeState(() => ({\n * foo: undefined as string | undefined,\n * bar: [] as number[],\n * baz: 1 as number | undefined,\n * }));\n *\n * state.records.foo = \"hi\";\n * console.log(state.records.foo); // prints \"hi\";\n * state.reset();\n * console.log(state.records.foo); // prints \"default\";\n *\n * // typeof state.records:\n * // {\n * // foo: string | undefined, // actual: undefined\n * // bar: number[], // actual: []\n * // baz: number | undefined, // actual: 1\n * // }\n * ```\n */\nexport class ImperativeState<S> {\n public records: S;\n\n /**\n * @param init - Function that creates the default state.\n */\n constructor(private init: () => S) {\n this.records = this.init();\n }\n\n reset() {\n this.records = this.init();\n }\n}\n"],
|
||||
"mappings": ";;;;;AAuBO,IAAM,kBAAN,MAAyB;AAAA;AAAA;AAAA;AAAA,EAM9B,YAAoB,MAAe;AAAf;AAClB,SAAK,UAAU,KAAK,KAAK;AAAA,EAC3B;AAAA,EA/BF,OAuBgC;AAAA;AAAA;AAAA,EAU9B,QAAQ;AACN,SAAK,UAAU,KAAK,KAAK;AAAA,EAC3B;AACF;",
|
||||
"names": []
|
||||
}
|
||||
+30592
File diff suppressed because one or more lines are too long
+7
File diff suppressed because one or more lines are too long
+2264
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+6964
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+77
@@ -0,0 +1,77 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
AbstractMermaidValueConverter,
|
||||
ArchitectureGrammarGeneratedModule,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-7N4EOEYR.mjs
|
||||
var ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "ArchitectureTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "ArchitectureTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["architecture"]);
|
||||
}
|
||||
};
|
||||
var ArchitectureValueConverter = class extends AbstractMermaidValueConverter {
|
||||
static {
|
||||
__name(this, "ArchitectureValueConverter");
|
||||
}
|
||||
static {
|
||||
__name2(this, "ArchitectureValueConverter");
|
||||
}
|
||||
runCustomConverter(rule, input, _cstNode) {
|
||||
if (rule.name === "ARCH_ICON") {
|
||||
return input.replace(/[()]/g, "").trim();
|
||||
} else if (rule.name === "ARCH_TEXT_ICON") {
|
||||
return input.replace(/["()]/g, "");
|
||||
} else if (rule.name === "ARCH_TITLE") {
|
||||
let result = input.replace(/^\[|]$/g, "").trim();
|
||||
if (result.startsWith('"') && result.endsWith('"') || result.startsWith("'") && result.endsWith("'")) {
|
||||
result = result.slice(1, -1);
|
||||
result = result.replace(/\\"/g, '"').replace(/\\'/g, "'");
|
||||
}
|
||||
return result.trim();
|
||||
}
|
||||
return void 0;
|
||||
}
|
||||
};
|
||||
var ArchitectureModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new ArchitectureTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new ArchitectureValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createArchitectureServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Architecture = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
ArchitectureGrammarGeneratedModule,
|
||||
ArchitectureModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Architecture);
|
||||
return { shared, Architecture };
|
||||
}
|
||||
__name(createArchitectureServices, "createArchitectureServices");
|
||||
__name2(createArchitectureServices, "createArchitectureServices");
|
||||
|
||||
export {
|
||||
ArchitectureModule,
|
||||
createArchitectureServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-7N4EOEYR.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n ArchitectureGrammarGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/architecture/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/architecture/tokenBuilder.ts\nvar ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"ArchitectureTokenBuilder\");\n }\n constructor() {\n super([\"architecture\"]);\n }\n};\n\n// src/language/architecture/valueConverter.ts\nvar ArchitectureValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"ArchitectureValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name === \"ARCH_ICON\") {\n return input.replace(/[()]/g, \"\").trim();\n } else if (rule.name === \"ARCH_TEXT_ICON\") {\n return input.replace(/[\"()]/g, \"\");\n } else if (rule.name === \"ARCH_TITLE\") {\n let result = input.replace(/^\\[|]$/g, \"\").trim();\n if (result.startsWith('\"') && result.endsWith('\"') || result.startsWith(\"'\") && result.endsWith(\"'\")) {\n result = result.slice(1, -1);\n result = result.replace(/\\\\\"/g, '\"').replace(/\\\\'/g, \"'\");\n }\n return result.trim();\n }\n return void 0;\n }\n};\n\n// src/language/architecture/module.ts\nvar ArchitectureModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new ArchitectureTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new ArchitectureValueConverter(), \"ValueConverter\")\n }\n};\nfunction createArchitectureServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Architecture = inject(\n createDefaultCoreModule({ shared }),\n ArchitectureGrammarGeneratedModule,\n ArchitectureModule\n );\n shared.ServiceRegistry.register(Architecture);\n return { shared, Architecture };\n}\n__name(createArchitectureServices, \"createArchitectureServices\");\n\nexport {\n ArchitectureModule,\n createArchitectureServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,2BAA2B,cAAc,4BAA4B;AAAA,EAjBzE,OAiByE;AAAA;AAAA;AAAA,EACvE,OAAO;AACL,IAAAA,QAAO,MAAM,0BAA0B;AAAA,EACzC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,cAAc,CAAC;AAAA,EACxB;AACF;AAGA,IAAI,6BAA6B,cAAc,8BAA8B;AAAA,EA3B7E,OA2B6E;AAAA;AAAA;AAAA,EAC3E,OAAO;AACL,IAAAA,QAAO,MAAM,4BAA4B;AAAA,EAC3C;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,aAAa;AAC7B,aAAO,MAAM,QAAQ,SAAS,EAAE,EAAE,KAAK;AAAA,IACzC,WAAW,KAAK,SAAS,kBAAkB;AACzC,aAAO,MAAM,QAAQ,UAAU,EAAE;AAAA,IACnC,WAAW,KAAK,SAAS,cAAc;AACrC,UAAI,SAAS,MAAM,QAAQ,WAAW,EAAE,EAAE,KAAK;AAC/C,UAAI,OAAO,WAAW,GAAG,KAAK,OAAO,SAAS,GAAG,KAAK,OAAO,WAAW,GAAG,KAAK,OAAO,SAAS,GAAG,GAAG;AACpG,iBAAS,OAAO,MAAM,GAAG,EAAE;AAC3B,iBAAS,OAAO,QAAQ,QAAQ,GAAG,EAAE,QAAQ,QAAQ,GAAG;AAAA,MAC1D;AACA,aAAO,OAAO,KAAK;AAAA,IACrB;AACA,WAAO;AAAA,EACT;AACF;AAGA,IAAI,qBAAqB;AAAA,EACvB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,yBAAyB,GAAG,cAAc;AAAA,IACzF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,2BAA2B,GAAG,gBAAgB;AAAA,EACjG;AACF;AACA,SAAS,2BAA2B,UAAU,iBAAiB;AAC7D,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,eAAe;AAAA,IACnB,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,YAAY;AAC5C,SAAO,EAAE,QAAQ,aAAa;AAChC;AAZS;AAaTA,QAAO,4BAA4B,4BAA4B;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
CommonValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
RadarGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-2KRD3SAO.mjs
|
||||
var RadarTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "RadarTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "RadarTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["radar-beta"]);
|
||||
}
|
||||
};
|
||||
var RadarModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new RadarTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createRadarServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Radar = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
RadarGrammarGeneratedModule,
|
||||
RadarModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Radar);
|
||||
return { shared, Radar };
|
||||
}
|
||||
__name(createRadarServices, "createRadarServices");
|
||||
__name2(createRadarServices, "createRadarServices");
|
||||
|
||||
export {
|
||||
RadarModule,
|
||||
createRadarServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-2KRD3SAO.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n MermaidGeneratedSharedModule,\n RadarGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/radar/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/radar/tokenBuilder.ts\nvar RadarTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"RadarTokenBuilder\");\n }\n constructor() {\n super([\"radar-beta\"]);\n }\n};\n\n// src/language/radar/module.ts\nvar RadarModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new RadarTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createRadarServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Radar = inject(\n createDefaultCoreModule({ shared }),\n RadarGrammarGeneratedModule,\n RadarModule\n );\n shared.ServiceRegistry.register(Radar);\n return { shared, Radar };\n}\n__name(createRadarServices, \"createRadarServices\");\n\nexport {\n RadarModule,\n createRadarServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,oBAAoB,cAAc,4BAA4B;AAAA,EAjBlE,OAiBkE;AAAA;AAAA;AAAA,EAChE,OAAO;AACL,IAAAA,QAAO,MAAM,mBAAmB;AAAA,EAClC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,YAAY,CAAC;AAAA,EACtB;AACF;AAGA,IAAI,cAAc;AAAA,EAChB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,kBAAkB,GAAG,cAAc;AAAA,IAClF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,oBAAoB,UAAU,iBAAiB;AACtD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,QAAQ;AAAA,IACZ,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,KAAK;AACrC,SAAO,EAAE,QAAQ,MAAM;AACzB;AAZS;AAaTA,QAAO,qBAAqB,qBAAqB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
AbstractMermaidValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
PieGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-AA7GKIK3.mjs
|
||||
var PieTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "PieTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "PieTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["pie", "showData"]);
|
||||
}
|
||||
};
|
||||
var PieValueConverter = class extends AbstractMermaidValueConverter {
|
||||
static {
|
||||
__name(this, "PieValueConverter");
|
||||
}
|
||||
static {
|
||||
__name2(this, "PieValueConverter");
|
||||
}
|
||||
runCustomConverter(rule, input, _cstNode) {
|
||||
if (rule.name !== "PIE_SECTION_LABEL") {
|
||||
return void 0;
|
||||
}
|
||||
return input.replace(/"/g, "").trim();
|
||||
}
|
||||
};
|
||||
var PieModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new PieTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new PieValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createPieServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const Pie = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
PieGrammarGeneratedModule,
|
||||
PieModule
|
||||
);
|
||||
shared.ServiceRegistry.register(Pie);
|
||||
return { shared, Pie };
|
||||
}
|
||||
__name(createPieServices, "createPieServices");
|
||||
__name2(createPieServices, "createPieServices");
|
||||
|
||||
export {
|
||||
PieModule,
|
||||
createPieServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-AA7GKIK3.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n PieGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/pie/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/pie/tokenBuilder.ts\nvar PieTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"PieTokenBuilder\");\n }\n constructor() {\n super([\"pie\", \"showData\"]);\n }\n};\n\n// src/language/pie/valueConverter.ts\nvar PieValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"PieValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name !== \"PIE_SECTION_LABEL\") {\n return void 0;\n }\n return input.replace(/\"/g, \"\").trim();\n }\n};\n\n// src/language/pie/module.ts\nvar PieModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new PieTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new PieValueConverter(), \"ValueConverter\")\n }\n};\nfunction createPieServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const Pie = inject(\n createDefaultCoreModule({ shared }),\n PieGrammarGeneratedModule,\n PieModule\n );\n shared.ServiceRegistry.register(Pie);\n return { shared, Pie };\n}\n__name(createPieServices, \"createPieServices\");\n\nexport {\n PieModule,\n createPieServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,kBAAkB,cAAc,4BAA4B;AAAA,EAjBhE,OAiBgE;AAAA;AAAA;AAAA,EAC9D,OAAO;AACL,IAAAA,QAAO,MAAM,iBAAiB;AAAA,EAChC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,OAAO,UAAU,CAAC;AAAA,EAC3B;AACF;AAGA,IAAI,oBAAoB,cAAc,8BAA8B;AAAA,EA3BpE,OA2BoE;AAAA;AAAA;AAAA,EAClE,OAAO;AACL,IAAAA,QAAO,MAAM,mBAAmB;AAAA,EAClC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,qBAAqB;AACrC,aAAO;AAAA,IACT;AACA,WAAO,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;AAAA,EACtC;AACF;AAGA,IAAI,YAAY;AAAA,EACd,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,gBAAgB,GAAG,cAAc;AAAA,IAChF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,kBAAkB,GAAG,gBAAgB;AAAA,EACxF;AACF;AACA,SAAS,kBAAkB,UAAU,iBAAiB;AACpD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,MAAM;AAAA,IACV,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,GAAG;AACnC,SAAO,EAAE,QAAQ,IAAI;AACvB;AAZS;AAaTA,QAAO,mBAAmB,mBAAmB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/globalStyles.ts
|
||||
var getIconStyles = /* @__PURE__ */ __name(() => `
|
||||
/* Font Awesome icon styling - consolidated */
|
||||
.label-icon {
|
||||
display: inline-block;
|
||||
height: 1em;
|
||||
overflow: visible;
|
||||
vertical-align: -0.125em;
|
||||
}
|
||||
|
||||
.node .label-icon path {
|
||||
fill: currentColor;
|
||||
stroke: revert;
|
||||
stroke-width: revert;
|
||||
}
|
||||
`, "getIconStyles");
|
||||
|
||||
export {
|
||||
getIconStyles
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/diagrams/globalStyles.ts"],
|
||||
"sourcesContent": ["export const getIconStyles = () => `\n /* Font Awesome icon styling - consolidated */\n .label-icon {\n display: inline-block;\n height: 1em;\n overflow: visible;\n vertical-align: -0.125em;\n }\n \n .node .label-icon path {\n fill: currentColor;\n stroke: revert;\n stroke-width: revert;\n }\n`;\n"],
|
||||
"mappings": ";;;;;AAAO,IAAM,gBAAgB,6BAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAAN;",
|
||||
"names": []
|
||||
}
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
AbstractMermaidValueConverter,
|
||||
EmptyFileSystem,
|
||||
MermaidGeneratedSharedModule,
|
||||
TreeViewGrammarGeneratedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-ORNJ4GCN.mjs
|
||||
var TreeViewValueConverter = class extends AbstractMermaidValueConverter {
|
||||
static {
|
||||
__name(this, "TreeViewValueConverter");
|
||||
}
|
||||
static {
|
||||
__name2(this, "TreeViewValueConverter");
|
||||
}
|
||||
runCustomConverter(rule, input, _cstNode) {
|
||||
if (rule.name === "INDENTATION") {
|
||||
return input?.length || 0;
|
||||
} else if (rule.name === "STRING2") {
|
||||
return input.substring(1, input.length - 1);
|
||||
}
|
||||
return void 0;
|
||||
}
|
||||
};
|
||||
var TreeViewTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "TreeViewTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "TreeViewTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["treeView-beta"]);
|
||||
}
|
||||
};
|
||||
var TreeViewModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new TreeViewTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new TreeViewValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createTreeViewServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const TreeView = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
TreeViewGrammarGeneratedModule,
|
||||
TreeViewModule
|
||||
);
|
||||
shared.ServiceRegistry.register(TreeView);
|
||||
return { shared, TreeView };
|
||||
}
|
||||
__name(createTreeViewServices, "createTreeViewServices");
|
||||
__name2(createTreeViewServices, "createTreeViewServices");
|
||||
|
||||
export {
|
||||
TreeViewModule,
|
||||
createTreeViewServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-ORNJ4GCN.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n AbstractMermaidValueConverter,\n MermaidGeneratedSharedModule,\n TreeViewGrammarGeneratedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/treeView/module.ts\nimport {\n EmptyFileSystem,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n inject\n} from \"langium\";\n\n// src/language/treeView/valueConverter.ts\nvar TreeViewValueConverter = class extends AbstractMermaidValueConverter {\n static {\n __name(this, \"TreeViewValueConverter\");\n }\n runCustomConverter(rule, input, _cstNode) {\n if (rule.name === \"INDENTATION\") {\n return input?.length || 0;\n } else if (rule.name === \"STRING2\") {\n return input.substring(1, input.length - 1);\n }\n return void 0;\n }\n};\n\n// src/language/treeView/tokenBuilder.ts\nvar TreeViewTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"TreeViewTokenBuilder\");\n }\n constructor() {\n super([\"treeView-beta\"]);\n }\n};\n\n// src/language/treeView/module.ts\nvar TreeViewModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new TreeViewTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new TreeViewValueConverter(), \"ValueConverter\")\n }\n};\nfunction createTreeViewServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const TreeView = inject(\n createDefaultCoreModule({ shared }),\n TreeViewGrammarGeneratedModule,\n TreeViewModule\n );\n shared.ServiceRegistry.register(TreeView);\n return { shared, TreeView };\n}\n__name(createTreeViewServices, \"createTreeViewServices\");\n\nexport {\n TreeViewModule,\n createTreeViewServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,yBAAyB,cAAc,8BAA8B;AAAA,EAjBzE,OAiByE;AAAA;AAAA;AAAA,EACvE,OAAO;AACL,IAAAA,QAAO,MAAM,wBAAwB;AAAA,EACvC;AAAA,EACA,mBAAmB,MAAM,OAAO,UAAU;AACxC,QAAI,KAAK,SAAS,eAAe;AAC/B,aAAO,OAAO,UAAU;AAAA,IAC1B,WAAW,KAAK,SAAS,WAAW;AAClC,aAAO,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC;AAAA,IAC5C;AACA,WAAO;AAAA,EACT;AACF;AAGA,IAAI,uBAAuB,cAAc,4BAA4B;AAAA,EAhCrE,OAgCqE;AAAA;AAAA;AAAA,EACnE,OAAO;AACL,IAAAA,QAAO,MAAM,sBAAsB;AAAA,EACrC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,eAAe,CAAC;AAAA,EACzB;AACF;AAGA,IAAI,iBAAiB;AAAA,EACnB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,cAAc;AAAA,IACrF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,uBAAuB,GAAG,gBAAgB;AAAA,EAC7F;AACF;AACA,SAAS,uBAAuB,UAAU,iBAAiB;AACzD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,QAAQ;AACxC,SAAO,EAAE,QAAQ,SAAS;AAC5B;AAZS;AAaTA,QAAO,wBAAwB,wBAAwB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
import {
|
||||
select_default
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/rendering-util/insertElementsForSize.js
|
||||
var getDiagramElement = /* @__PURE__ */ __name((id, securityLevel) => {
|
||||
let sandboxElement;
|
||||
if (securityLevel === "sandbox") {
|
||||
sandboxElement = select_default("#i" + id);
|
||||
}
|
||||
const root = securityLevel === "sandbox" ? select_default(sandboxElement.nodes()[0].contentDocument.body) : select_default("body");
|
||||
const svg = root.select(`[id="${id}"]`);
|
||||
return svg;
|
||||
}, "getDiagramElement");
|
||||
|
||||
export {
|
||||
getDiagramElement
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/rendering-util/insertElementsForSize.js"],
|
||||
"sourcesContent": ["import { select } from 'd3';\n\nexport const getDiagramElement = (id, securityLevel) => {\n let sandboxElement;\n if (securityLevel === 'sandbox') {\n sandboxElement = select('#i' + id);\n }\n const root =\n securityLevel === 'sandbox'\n ? select(sandboxElement.nodes()[0].contentDocument.body)\n : select('body');\n\n const svg = root.select(`[id=\"${id}\"]`);\n\n // Run the renderer. This is what draws the final graph.\n\n return svg;\n};\n"],
|
||||
"mappings": ";;;;;;;;AAEO,IAAM,oBAAoB,wBAAC,IAAI,kBAAkB;AACtD,MAAI;AACJ,MAAI,kBAAkB,WAAW;AAC/B,qBAAiB,eAAO,OAAO,EAAE;AAAA,EACnC;AACA,QAAM,OACJ,kBAAkB,YACd,eAAO,eAAe,MAAM,EAAE,CAAC,EAAE,gBAAgB,IAAI,IACrD,eAAO,MAAM;AAEnB,QAAM,MAAM,KAAK,OAAO,QAAQ,EAAE,IAAI;AAItC,SAAO;AACT,GAfiC;",
|
||||
"names": []
|
||||
}
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/rendering-util/labelTransform.ts
|
||||
var computeLabelTransform = /* @__PURE__ */ __name((bbox, useHtmlLabels) => {
|
||||
if (useHtmlLabels) {
|
||||
return "translate(" + -bbox.width / 2 + ", " + -bbox.height / 2 + ")";
|
||||
}
|
||||
const x = bbox.x ?? 0;
|
||||
const y = bbox.y ?? 0;
|
||||
return "translate(" + -(x + bbox.width / 2) + ", " + -(y + bbox.height / 2) + ")";
|
||||
}, "computeLabelTransform");
|
||||
|
||||
// src/utils/lineWithOffset.ts
|
||||
var markerOffsets = {
|
||||
aggregation: 17.25,
|
||||
extension: 17.25,
|
||||
composition: 17.25,
|
||||
dependency: 6,
|
||||
lollipop: 13.5,
|
||||
arrow_point: 4,
|
||||
arrow_barb: 0,
|
||||
arrow_barb_neo: 5.5
|
||||
//arrow_cross: 24,
|
||||
};
|
||||
var markerOffsets2 = {
|
||||
arrow_point: 4,
|
||||
arrow_cross: 12.5,
|
||||
arrow_circle: 12.5
|
||||
};
|
||||
function calculateDeltaAndAngle(point1, point2) {
|
||||
if (point1 === void 0 || point2 === void 0) {
|
||||
return { angle: 0, deltaX: 0, deltaY: 0 };
|
||||
}
|
||||
point1 = pointTransformer(point1);
|
||||
point2 = pointTransformer(point2);
|
||||
const [x1, y1] = [point1.x, point1.y];
|
||||
const [x2, y2] = [point2.x, point2.y];
|
||||
const deltaX = x2 - x1;
|
||||
const deltaY = y2 - y1;
|
||||
return { angle: Math.atan(deltaY / deltaX), deltaX, deltaY };
|
||||
}
|
||||
__name(calculateDeltaAndAngle, "calculateDeltaAndAngle");
|
||||
var pointTransformer = /* @__PURE__ */ __name((data) => {
|
||||
if (Array.isArray(data)) {
|
||||
return { x: data[0], y: data[1] };
|
||||
}
|
||||
return data;
|
||||
}, "pointTransformer");
|
||||
var getLineFunctionsWithOffset = /* @__PURE__ */ __name((edge) => {
|
||||
return {
|
||||
x: /* @__PURE__ */ __name(function(d, i, data) {
|
||||
let offset = 0;
|
||||
const DIRECTION = pointTransformer(data[0]).x < pointTransformer(data[data.length - 1]).x ? "left" : "right";
|
||||
if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
|
||||
const { angle, deltaX } = calculateDeltaAndAngle(data[0], data[1]);
|
||||
offset = markerOffsets[edge.arrowTypeStart] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
|
||||
} else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
|
||||
const { angle, deltaX } = calculateDeltaAndAngle(
|
||||
data[data.length - 1],
|
||||
data[data.length - 2]
|
||||
);
|
||||
offset = markerOffsets[edge.arrowTypeEnd] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
|
||||
}
|
||||
const differenceToEnd = Math.abs(
|
||||
pointTransformer(d).x - pointTransformer(data[data.length - 1]).x
|
||||
);
|
||||
const differenceInYEnd = Math.abs(
|
||||
pointTransformer(d).y - pointTransformer(data[data.length - 1]).y
|
||||
);
|
||||
const differenceToStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
|
||||
const differenceInYStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
|
||||
const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
|
||||
const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
|
||||
const extraRoom = 1;
|
||||
if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInYEnd < endMarkerHeight) {
|
||||
let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
|
||||
adjustment *= DIRECTION === "right" ? -1 : 1;
|
||||
offset -= adjustment;
|
||||
}
|
||||
if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInYStart < startMarkerHeight) {
|
||||
let adjustment = startMarkerHeight + extraRoom - differenceToStart;
|
||||
adjustment *= DIRECTION === "right" ? -1 : 1;
|
||||
offset += adjustment;
|
||||
}
|
||||
return pointTransformer(d).x + offset;
|
||||
}, "x"),
|
||||
y: /* @__PURE__ */ __name(function(d, i, data) {
|
||||
let offset = 0;
|
||||
const DIRECTION = pointTransformer(data[0]).y < pointTransformer(data[data.length - 1]).y ? "down" : "up";
|
||||
if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
|
||||
const { angle, deltaY } = calculateDeltaAndAngle(data[0], data[1]);
|
||||
offset = markerOffsets[edge.arrowTypeStart] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
|
||||
} else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
|
||||
const { angle, deltaY } = calculateDeltaAndAngle(
|
||||
data[data.length - 1],
|
||||
data[data.length - 2]
|
||||
);
|
||||
offset = markerOffsets[edge.arrowTypeEnd] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
|
||||
}
|
||||
const differenceToEnd = Math.abs(
|
||||
pointTransformer(d).y - pointTransformer(data[data.length - 1]).y
|
||||
);
|
||||
const differenceInXEnd = Math.abs(
|
||||
pointTransformer(d).x - pointTransformer(data[data.length - 1]).x
|
||||
);
|
||||
const differenceToStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
|
||||
const differenceInXStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
|
||||
const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
|
||||
const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
|
||||
const extraRoom = 1;
|
||||
if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInXEnd < endMarkerHeight) {
|
||||
let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
|
||||
adjustment *= DIRECTION === "up" ? -1 : 1;
|
||||
offset -= adjustment;
|
||||
}
|
||||
if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInXStart < startMarkerHeight) {
|
||||
let adjustment = startMarkerHeight + extraRoom - differenceToStart;
|
||||
adjustment *= DIRECTION === "up" ? -1 : 1;
|
||||
offset += adjustment;
|
||||
}
|
||||
return pointTransformer(d).y + offset;
|
||||
}, "y")
|
||||
};
|
||||
}, "getLineFunctionsWithOffset");
|
||||
if (void 0) {
|
||||
const { it, expect, describe } = void 0;
|
||||
describe("calculateDeltaAndAngle", () => {
|
||||
it("should calculate the angle and deltas between two points", () => {
|
||||
expect(calculateDeltaAndAngle([0, 0], [0, 1])).toStrictEqual({
|
||||
angle: 1.5707963267948966,
|
||||
deltaX: 0,
|
||||
deltaY: 1
|
||||
});
|
||||
expect(calculateDeltaAndAngle([1, 0], [0, -1])).toStrictEqual({
|
||||
angle: 0.7853981633974483,
|
||||
deltaX: -1,
|
||||
deltaY: -1
|
||||
});
|
||||
expect(calculateDeltaAndAngle({ x: 1, y: 0 }, [0, -1])).toStrictEqual({
|
||||
angle: 0.7853981633974483,
|
||||
deltaX: -1,
|
||||
deltaY: -1
|
||||
});
|
||||
expect(calculateDeltaAndAngle({ x: 1, y: 0 }, { x: 1, y: 0 })).toStrictEqual({
|
||||
angle: NaN,
|
||||
deltaX: 0,
|
||||
deltaY: 0
|
||||
});
|
||||
});
|
||||
it("should calculate the angle and deltas if one point in undefined", () => {
|
||||
expect(calculateDeltaAndAngle(void 0, [0, 1])).toStrictEqual({
|
||||
angle: 0,
|
||||
deltaX: 0,
|
||||
deltaY: 0
|
||||
});
|
||||
expect(calculateDeltaAndAngle([0, 1], void 0)).toStrictEqual({
|
||||
angle: 0,
|
||||
deltaX: 0,
|
||||
deltaY: 0
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export {
|
||||
computeLabelTransform,
|
||||
markerOffsets,
|
||||
markerOffsets2,
|
||||
getLineFunctionsWithOffset
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+126
@@ -0,0 +1,126 @@
|
||||
import {
|
||||
Map_default,
|
||||
baseGetTag_default,
|
||||
getNative_default,
|
||||
isArguments_default,
|
||||
isArrayLike_default,
|
||||
isArray_default,
|
||||
isBuffer_default,
|
||||
isPrototype_default,
|
||||
isTypedArray_default,
|
||||
overArg_default,
|
||||
root_default,
|
||||
toSource_default
|
||||
} from "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeKeys.js
|
||||
var nativeKeys = overArg_default(Object.keys, Object);
|
||||
var nativeKeys_default = nativeKeys;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseKeys.js
|
||||
var objectProto = Object.prototype;
|
||||
var hasOwnProperty = objectProto.hasOwnProperty;
|
||||
function baseKeys(object) {
|
||||
if (!isPrototype_default(object)) {
|
||||
return nativeKeys_default(object);
|
||||
}
|
||||
var result = [];
|
||||
for (var key in Object(object)) {
|
||||
if (hasOwnProperty.call(object, key) && key != "constructor") {
|
||||
result.push(key);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
__name(baseKeys, "baseKeys");
|
||||
var baseKeys_default = baseKeys;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_DataView.js
|
||||
var DataView = getNative_default(root_default, "DataView");
|
||||
var DataView_default = DataView;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Promise.js
|
||||
var Promise2 = getNative_default(root_default, "Promise");
|
||||
var Promise_default = Promise2;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Set.js
|
||||
var Set = getNative_default(root_default, "Set");
|
||||
var Set_default = Set;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_WeakMap.js
|
||||
var WeakMap = getNative_default(root_default, "WeakMap");
|
||||
var WeakMap_default = WeakMap;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getTag.js
|
||||
var mapTag = "[object Map]";
|
||||
var objectTag = "[object Object]";
|
||||
var promiseTag = "[object Promise]";
|
||||
var setTag = "[object Set]";
|
||||
var weakMapTag = "[object WeakMap]";
|
||||
var dataViewTag = "[object DataView]";
|
||||
var dataViewCtorString = toSource_default(DataView_default);
|
||||
var mapCtorString = toSource_default(Map_default);
|
||||
var promiseCtorString = toSource_default(Promise_default);
|
||||
var setCtorString = toSource_default(Set_default);
|
||||
var weakMapCtorString = toSource_default(WeakMap_default);
|
||||
var getTag = baseGetTag_default;
|
||||
if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag || Map_default && getTag(new Map_default()) != mapTag || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag) {
|
||||
getTag = /* @__PURE__ */ __name(function(value) {
|
||||
var result = baseGetTag_default(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
|
||||
if (ctorString) {
|
||||
switch (ctorString) {
|
||||
case dataViewCtorString:
|
||||
return dataViewTag;
|
||||
case mapCtorString:
|
||||
return mapTag;
|
||||
case promiseCtorString:
|
||||
return promiseTag;
|
||||
case setCtorString:
|
||||
return setTag;
|
||||
case weakMapCtorString:
|
||||
return weakMapTag;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}, "getTag");
|
||||
}
|
||||
var getTag_default = getTag;
|
||||
|
||||
// ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js
|
||||
var mapTag2 = "[object Map]";
|
||||
var setTag2 = "[object Set]";
|
||||
var objectProto2 = Object.prototype;
|
||||
var hasOwnProperty2 = objectProto2.hasOwnProperty;
|
||||
function isEmpty(value) {
|
||||
if (value == null) {
|
||||
return true;
|
||||
}
|
||||
if (isArrayLike_default(value) && (isArray_default(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer_default(value) || isTypedArray_default(value) || isArguments_default(value))) {
|
||||
return !value.length;
|
||||
}
|
||||
var tag = getTag_default(value);
|
||||
if (tag == mapTag2 || tag == setTag2) {
|
||||
return !value.size;
|
||||
}
|
||||
if (isPrototype_default(value)) {
|
||||
return !baseKeys_default(value).length;
|
||||
}
|
||||
for (var key in value) {
|
||||
if (hasOwnProperty2.call(value, key)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
__name(isEmpty, "isEmpty");
|
||||
var isEmpty_default = isEmpty;
|
||||
|
||||
export {
|
||||
baseKeys_default,
|
||||
Set_default,
|
||||
getTag_default,
|
||||
isEmpty_default
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+111
@@ -0,0 +1,111 @@
|
||||
import {
|
||||
getConfig2 as getConfig
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/rendering-util/rendering-elements/shapes/handDrawnShapeStyles.ts
|
||||
var solidStateFill = /* @__PURE__ */ __name((color) => {
|
||||
const { handDrawnSeed } = getConfig();
|
||||
return {
|
||||
fill: color,
|
||||
hachureAngle: 120,
|
||||
// angle of hachure,
|
||||
hachureGap: 4,
|
||||
fillWeight: 2,
|
||||
roughness: 0.7,
|
||||
stroke: color,
|
||||
seed: handDrawnSeed
|
||||
};
|
||||
}, "solidStateFill");
|
||||
var compileStyles = /* @__PURE__ */ __name((node) => {
|
||||
const stylesMap = styles2Map([
|
||||
...node.cssCompiledStyles || [],
|
||||
...node.cssStyles || [],
|
||||
...node.labelStyle || []
|
||||
]);
|
||||
return { stylesMap, stylesArray: [...stylesMap] };
|
||||
}, "compileStyles");
|
||||
var styles2Map = /* @__PURE__ */ __name((styles) => {
|
||||
const styleMap = /* @__PURE__ */ new Map();
|
||||
styles.forEach((style) => {
|
||||
const [key, value] = style.split(":");
|
||||
styleMap.set(key.trim(), value?.trim());
|
||||
});
|
||||
return styleMap;
|
||||
}, "styles2Map");
|
||||
var isLabelStyle = /* @__PURE__ */ __name((key) => {
|
||||
return key === "color" || key === "font-size" || key === "font-family" || key === "font-weight" || key === "font-style" || key === "text-decoration" || key === "text-align" || key === "text-transform" || key === "line-height" || key === "letter-spacing" || key === "word-spacing" || key === "text-shadow" || key === "text-overflow" || key === "white-space" || key === "word-wrap" || key === "word-break" || key === "overflow-wrap" || key === "hyphens";
|
||||
}, "isLabelStyle");
|
||||
var styles2String = /* @__PURE__ */ __name((node) => {
|
||||
const { stylesArray } = compileStyles(node);
|
||||
const labelStyles = [];
|
||||
const nodeStyles = [];
|
||||
const borderStyles = [];
|
||||
const backgroundStyles = [];
|
||||
stylesArray.forEach((style) => {
|
||||
const key = style[0];
|
||||
if (isLabelStyle(key)) {
|
||||
labelStyles.push(style.join(":") + " !important");
|
||||
} else {
|
||||
nodeStyles.push(style.join(":") + " !important");
|
||||
if (key.includes("stroke")) {
|
||||
borderStyles.push(style.join(":") + " !important");
|
||||
}
|
||||
if (key === "fill") {
|
||||
backgroundStyles.push(style.join(":") + " !important");
|
||||
}
|
||||
}
|
||||
});
|
||||
return {
|
||||
labelStyles: labelStyles.join(";"),
|
||||
nodeStyles: nodeStyles.join(";"),
|
||||
stylesArray,
|
||||
borderStyles,
|
||||
backgroundStyles
|
||||
};
|
||||
}, "styles2String");
|
||||
var userNodeOverrides = /* @__PURE__ */ __name((node, options) => {
|
||||
const { themeVariables, handDrawnSeed } = getConfig();
|
||||
const { nodeBorder, mainBkg } = themeVariables;
|
||||
const { stylesMap } = compileStyles(node);
|
||||
const result = Object.assign(
|
||||
{
|
||||
roughness: 0.7,
|
||||
fill: stylesMap.get("fill") || mainBkg,
|
||||
fillStyle: "hachure",
|
||||
// solid fill
|
||||
fillWeight: 4,
|
||||
hachureGap: 5.2,
|
||||
stroke: stylesMap.get("stroke") || nodeBorder,
|
||||
seed: handDrawnSeed,
|
||||
strokeWidth: stylesMap.get("stroke-width")?.replace("px", "") || 1.3,
|
||||
fillLineDash: [0, 0],
|
||||
strokeLineDash: getStrokeDashArray(stylesMap.get("stroke-dasharray"))
|
||||
},
|
||||
options
|
||||
);
|
||||
return result;
|
||||
}, "userNodeOverrides");
|
||||
var getStrokeDashArray = /* @__PURE__ */ __name((strokeDasharrayStyle) => {
|
||||
if (!strokeDasharrayStyle) {
|
||||
return [0, 0];
|
||||
}
|
||||
const dashArray = strokeDasharrayStyle.trim().split(/\s+/).map(Number);
|
||||
if (dashArray.length === 1) {
|
||||
const val = isNaN(dashArray[0]) ? 0 : dashArray[0];
|
||||
return [val, val];
|
||||
}
|
||||
const first = isNaN(dashArray[0]) ? 0 : dashArray[0];
|
||||
const second = isNaN(dashArray[1]) ? 0 : dashArray[1];
|
||||
return [first, second];
|
||||
}, "getStrokeDashArray");
|
||||
|
||||
export {
|
||||
solidStateFill,
|
||||
compileStyles,
|
||||
isLabelStyle,
|
||||
styles2String,
|
||||
userNodeOverrides
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/rendering-util/rendering-elements/shapes/handDrawnShapeStyles.ts"],
|
||||
"sourcesContent": ["import { getConfig } from '../../../diagram-api/diagramAPI.js';\nimport type { Node } from '../../types.js';\n\n// Striped fill like start or fork nodes in state diagrams\nexport const solidStateFill = (color: string) => {\n const { handDrawnSeed } = getConfig();\n return {\n fill: color,\n hachureAngle: 120, // angle of hachure,\n hachureGap: 4,\n fillWeight: 2,\n roughness: 0.7,\n stroke: color,\n seed: handDrawnSeed,\n };\n};\n\nexport const compileStyles = (node: Node) => {\n // node.cssCompiledStyles is an array of strings in the form of 'key: value' where key is the css property and value is the value\n // the array is the styles of node from the classes it is using\n // node.cssStyles is an array of styles directly set on the node\n // concat the arrays and remove duplicates such that the values from node.cssStyles are used if there are duplicates\n const stylesMap = styles2Map([\n ...(node.cssCompiledStyles || []),\n ...(node.cssStyles || []),\n ...(node.labelStyle || []),\n ]);\n return { stylesMap, stylesArray: [...stylesMap] };\n};\n\nexport const styles2Map = (styles: string[]) => {\n const styleMap = new Map<string, string>();\n styles.forEach((style) => {\n const [key, value] = style.split(':');\n styleMap.set(key.trim(), value?.trim());\n });\n return styleMap;\n};\nexport const isLabelStyle = (key: string) => {\n return (\n key === 'color' ||\n key === 'font-size' ||\n key === 'font-family' ||\n key === 'font-weight' ||\n key === 'font-style' ||\n key === 'text-decoration' ||\n key === 'text-align' ||\n key === 'text-transform' ||\n key === 'line-height' ||\n key === 'letter-spacing' ||\n key === 'word-spacing' ||\n key === 'text-shadow' ||\n key === 'text-overflow' ||\n key === 'white-space' ||\n key === 'word-wrap' ||\n key === 'word-break' ||\n key === 'overflow-wrap' ||\n key === 'hyphens'\n );\n};\nexport const styles2String = (node: Node) => {\n const { stylesArray } = compileStyles(node);\n const labelStyles: string[] = [];\n const nodeStyles: string[] = [];\n const borderStyles: string[] = [];\n const backgroundStyles: string[] = [];\n\n stylesArray.forEach((style) => {\n const key = style[0];\n if (isLabelStyle(key)) {\n labelStyles.push(style.join(':') + ' !important');\n } else {\n nodeStyles.push(style.join(':') + ' !important');\n if (key.includes('stroke')) {\n borderStyles.push(style.join(':') + ' !important');\n }\n if (key === 'fill') {\n backgroundStyles.push(style.join(':') + ' !important');\n }\n }\n });\n\n return {\n labelStyles: labelStyles.join(';'),\n nodeStyles: nodeStyles.join(';'),\n stylesArray,\n borderStyles,\n backgroundStyles,\n };\n};\n\n// Striped fill like start or fork nodes in state diagrams\n// TODO remove any\nexport const userNodeOverrides = (node: Node, options: any) => {\n const { themeVariables, handDrawnSeed } = getConfig();\n const { nodeBorder, mainBkg } = themeVariables;\n const { stylesMap } = compileStyles(node);\n\n // index the style array to a map object\n const result = Object.assign(\n {\n roughness: 0.7,\n fill: stylesMap.get('fill') || mainBkg,\n fillStyle: 'hachure', // solid fill\n fillWeight: 4,\n hachureGap: 5.2,\n stroke: stylesMap.get('stroke') || nodeBorder,\n seed: handDrawnSeed,\n strokeWidth: stylesMap.get('stroke-width')?.replace('px', '') || 1.3,\n fillLineDash: [0, 0],\n strokeLineDash: getStrokeDashArray(stylesMap.get('stroke-dasharray')),\n },\n options\n );\n return result;\n};\n\nconst getStrokeDashArray = (strokeDasharrayStyle?: string) => {\n if (!strokeDasharrayStyle) {\n return [0, 0];\n }\n const dashArray = strokeDasharrayStyle.trim().split(/\\s+/).map(Number);\n if (dashArray.length === 1) {\n const val = isNaN(dashArray[0]) ? 0 : dashArray[0];\n return [val, val];\n }\n const first = isNaN(dashArray[0]) ? 0 : dashArray[0];\n const second = isNaN(dashArray[1]) ? 0 : dashArray[1];\n return [first, second];\n};\n"],
|
||||
"mappings": ";;;;;;;;AAIO,IAAM,iBAAiB,wBAAC,UAAkB;AAC/C,QAAM,EAAE,cAAc,IAAI,UAAU;AACpC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,cAAc;AAAA;AAAA,IACd,YAAY;AAAA,IACZ,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,QAAQ;AAAA,IACR,MAAM;AAAA,EACR;AACF,GAX8B;AAavB,IAAM,gBAAgB,wBAAC,SAAe;AAK3C,QAAM,YAAY,WAAW;AAAA,IAC3B,GAAI,KAAK,qBAAqB,CAAC;AAAA,IAC/B,GAAI,KAAK,aAAa,CAAC;AAAA,IACvB,GAAI,KAAK,cAAc,CAAC;AAAA,EAC1B,CAAC;AACD,SAAO,EAAE,WAAW,aAAa,CAAC,GAAG,SAAS,EAAE;AAClD,GAX6B;AAatB,IAAM,aAAa,wBAAC,WAAqB;AAC9C,QAAM,WAAW,oBAAI,IAAoB;AACzC,SAAO,QAAQ,CAAC,UAAU;AACxB,UAAM,CAAC,KAAK,KAAK,IAAI,MAAM,MAAM,GAAG;AACpC,aAAS,IAAI,IAAI,KAAK,GAAG,OAAO,KAAK,CAAC;AAAA,EACxC,CAAC;AACD,SAAO;AACT,GAP0B;AAQnB,IAAM,eAAe,wBAAC,QAAgB;AAC3C,SACE,QAAQ,WACR,QAAQ,eACR,QAAQ,iBACR,QAAQ,iBACR,QAAQ,gBACR,QAAQ,qBACR,QAAQ,gBACR,QAAQ,oBACR,QAAQ,iBACR,QAAQ,oBACR,QAAQ,kBACR,QAAQ,iBACR,QAAQ,mBACR,QAAQ,iBACR,QAAQ,eACR,QAAQ,gBACR,QAAQ,mBACR,QAAQ;AAEZ,GArB4B;AAsBrB,IAAM,gBAAgB,wBAAC,SAAe;AAC3C,QAAM,EAAE,YAAY,IAAI,cAAc,IAAI;AAC1C,QAAM,cAAwB,CAAC;AAC/B,QAAM,aAAuB,CAAC;AAC9B,QAAM,eAAyB,CAAC;AAChC,QAAM,mBAA6B,CAAC;AAEpC,cAAY,QAAQ,CAAC,UAAU;AAC7B,UAAM,MAAM,MAAM,CAAC;AACnB,QAAI,aAAa,GAAG,GAAG;AACrB,kBAAY,KAAK,MAAM,KAAK,GAAG,IAAI,aAAa;AAAA,IAClD,OAAO;AACL,iBAAW,KAAK,MAAM,KAAK,GAAG,IAAI,aAAa;AAC/C,UAAI,IAAI,SAAS,QAAQ,GAAG;AAC1B,qBAAa,KAAK,MAAM,KAAK,GAAG,IAAI,aAAa;AAAA,MACnD;AACA,UAAI,QAAQ,QAAQ;AAClB,yBAAiB,KAAK,MAAM,KAAK,GAAG,IAAI,aAAa;AAAA,MACvD;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,aAAa,YAAY,KAAK,GAAG;AAAA,IACjC,YAAY,WAAW,KAAK,GAAG;AAAA,IAC/B;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF,GA7B6B;AAiCtB,IAAM,oBAAoB,wBAAC,MAAY,YAAiB;AAC7D,QAAM,EAAE,gBAAgB,cAAc,IAAI,UAAU;AACpD,QAAM,EAAE,YAAY,QAAQ,IAAI;AAChC,QAAM,EAAE,UAAU,IAAI,cAAc,IAAI;AAGxC,QAAM,SAAS,OAAO;AAAA,IACpB;AAAA,MACE,WAAW;AAAA,MACX,MAAM,UAAU,IAAI,MAAM,KAAK;AAAA,MAC/B,WAAW;AAAA;AAAA,MACX,YAAY;AAAA,MACZ,YAAY;AAAA,MACZ,QAAQ,UAAU,IAAI,QAAQ,KAAK;AAAA,MACnC,MAAM;AAAA,MACN,aAAa,UAAU,IAAI,cAAc,GAAG,QAAQ,MAAM,EAAE,KAAK;AAAA,MACjE,cAAc,CAAC,GAAG,CAAC;AAAA,MACnB,gBAAgB,mBAAmB,UAAU,IAAI,kBAAkB,CAAC;AAAA,IACtE;AAAA,IACA;AAAA,EACF;AACA,SAAO;AACT,GAtBiC;AAwBjC,IAAM,qBAAqB,wBAAC,yBAAkC;AAC5D,MAAI,CAAC,sBAAsB;AACzB,WAAO,CAAC,GAAG,CAAC;AAAA,EACd;AACA,QAAM,YAAY,qBAAqB,KAAK,EAAE,MAAM,KAAK,EAAE,IAAI,MAAM;AACrE,MAAI,UAAU,WAAW,GAAG;AAC1B,UAAM,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,IAAI,UAAU,CAAC;AACjD,WAAO,CAAC,KAAK,GAAG;AAAA,EAClB;AACA,QAAM,QAAQ,MAAM,UAAU,CAAC,CAAC,IAAI,IAAI,UAAU,CAAC;AACnD,QAAM,SAAS,MAAM,UAAU,CAAC,CAAC,IAAI,IAAI,UAAU,CAAC;AACpD,SAAO,CAAC,OAAO,MAAM;AACvB,GAZ2B;",
|
||||
"names": []
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/common/populateCommonDb.ts
|
||||
function populateCommonDb(ast, db) {
|
||||
if (ast.accDescr) {
|
||||
db.setAccDescription?.(ast.accDescr);
|
||||
}
|
||||
if (ast.accTitle) {
|
||||
db.setAccTitle?.(ast.accTitle);
|
||||
}
|
||||
if (ast.title) {
|
||||
db.setDiagramTitle?.(ast.title);
|
||||
}
|
||||
}
|
||||
__name(populateCommonDb, "populateCommonDb");
|
||||
|
||||
export {
|
||||
populateCommonDb
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/diagrams/common/populateCommonDb.ts"],
|
||||
"sourcesContent": ["import type { DiagramAST } from '@mermaid-js/parser';\nimport type { DiagramDB } from '../../diagram-api/types.js';\n\nexport function populateCommonDb(ast: DiagramAST, db: DiagramDB) {\n if (ast.accDescr) {\n db.setAccDescription?.(ast.accDescr);\n }\n if (ast.accTitle) {\n db.setAccTitle?.(ast.accTitle);\n }\n if (ast.title) {\n db.setDiagramTitle?.(ast.title);\n }\n}\n"],
|
||||
"mappings": ";;;;;AAGO,SAAS,iBAAiB,KAAiB,IAAe;AAC/D,MAAI,IAAI,UAAU;AAChB,OAAG,oBAAoB,IAAI,QAAQ;AAAA,EACrC;AACA,MAAI,IAAI,UAAU;AAChB,OAAG,cAAc,IAAI,QAAQ;AAAA,EAC/B;AACA,MAAI,IAAI,OAAO;AACb,OAAG,kBAAkB,IAAI,KAAK;AAAA,EAChC;AACF;AAVgB;",
|
||||
"names": []
|
||||
}
|
||||
+26233
File diff suppressed because one or more lines are too long
+7
File diff suppressed because one or more lines are too long
+54
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
AbstractMermaidTokenBuilder,
|
||||
CommonValueConverter,
|
||||
EmptyFileSystem,
|
||||
GitGraphGrammarGeneratedModule,
|
||||
MermaidGeneratedSharedModule,
|
||||
__name as __name2,
|
||||
createDefaultCoreModule,
|
||||
createDefaultSharedCoreModule,
|
||||
inject,
|
||||
lib_exports
|
||||
} from "./chunk-WEB62QT6.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../parser/dist/chunks/mermaid-parser.core/chunk-67CJDMHE.mjs
|
||||
var GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {
|
||||
static {
|
||||
__name(this, "GitGraphTokenBuilder");
|
||||
}
|
||||
static {
|
||||
__name2(this, "GitGraphTokenBuilder");
|
||||
}
|
||||
constructor() {
|
||||
super(["gitGraph"]);
|
||||
}
|
||||
};
|
||||
var GitGraphModule = {
|
||||
parser: {
|
||||
TokenBuilder: /* @__PURE__ */ __name2(() => new GitGraphTokenBuilder(), "TokenBuilder"),
|
||||
ValueConverter: /* @__PURE__ */ __name2(() => new CommonValueConverter(), "ValueConverter")
|
||||
}
|
||||
};
|
||||
function createGitGraphServices(context = EmptyFileSystem) {
|
||||
const shared = inject(
|
||||
createDefaultSharedCoreModule(context),
|
||||
MermaidGeneratedSharedModule
|
||||
);
|
||||
const GitGraph = inject(
|
||||
createDefaultCoreModule({ shared }),
|
||||
GitGraphGrammarGeneratedModule,
|
||||
GitGraphModule
|
||||
);
|
||||
shared.ServiceRegistry.register(GitGraph);
|
||||
return { shared, GitGraph };
|
||||
}
|
||||
__name(createGitGraphServices, "createGitGraphServices");
|
||||
__name2(createGitGraphServices, "createGitGraphServices");
|
||||
|
||||
export {
|
||||
GitGraphModule,
|
||||
createGitGraphServices
|
||||
};
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../../parser/dist/chunks/mermaid-parser.core/chunk-67CJDMHE.mjs"],
|
||||
"sourcesContent": ["import {\n AbstractMermaidTokenBuilder,\n CommonValueConverter,\n GitGraphGrammarGeneratedModule,\n MermaidGeneratedSharedModule,\n __name\n} from \"./chunk-K5T4RW27.mjs\";\n\n// src/language/gitGraph/module.ts\nimport {\n inject,\n createDefaultCoreModule,\n createDefaultSharedCoreModule,\n EmptyFileSystem\n} from \"langium\";\n\n// src/language/gitGraph/tokenBuilder.ts\nvar GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {\n static {\n __name(this, \"GitGraphTokenBuilder\");\n }\n constructor() {\n super([\"gitGraph\"]);\n }\n};\n\n// src/language/gitGraph/module.ts\nvar GitGraphModule = {\n parser: {\n TokenBuilder: /* @__PURE__ */ __name(() => new GitGraphTokenBuilder(), \"TokenBuilder\"),\n ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter(), \"ValueConverter\")\n }\n};\nfunction createGitGraphServices(context = EmptyFileSystem) {\n const shared = inject(\n createDefaultSharedCoreModule(context),\n MermaidGeneratedSharedModule\n );\n const GitGraph = inject(\n createDefaultCoreModule({ shared }),\n GitGraphGrammarGeneratedModule,\n GitGraphModule\n );\n shared.ServiceRegistry.register(GitGraph);\n return { shared, GitGraph };\n}\n__name(createGitGraphServices, \"createGitGraphServices\");\n\nexport {\n GitGraphModule,\n createGitGraphServices\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;AAiBA,IAAI,uBAAuB,cAAc,4BAA4B;AAAA,EAjBrE,OAiBqE;AAAA;AAAA;AAAA,EACnE,OAAO;AACL,IAAAA,QAAO,MAAM,sBAAsB;AAAA,EACrC;AAAA,EACA,cAAc;AACZ,UAAM,CAAC,UAAU,CAAC;AAAA,EACpB;AACF;AAGA,IAAI,iBAAiB;AAAA,EACnB,QAAQ;AAAA,IACN,cAA8B,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,cAAc;AAAA,IACrF,gBAAgC,gBAAAA,QAAO,MAAM,IAAI,qBAAqB,GAAG,gBAAgB;AAAA,EAC3F;AACF;AACA,SAAS,uBAAuB,UAAU,iBAAiB;AACzD,QAAM,SAAS;AAAA,IACb,8BAA8B,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,wBAAwB,EAAE,OAAO,CAAC;AAAA,IAClC;AAAA,IACA;AAAA,EACF;AACA,SAAO,gBAAgB,SAAS,QAAQ;AACxC,SAAO,EAAE,QAAQ,SAAS;AAC5B;AAZS;AAaTA,QAAO,wBAAwB,wBAAwB;",
|
||||
"names": ["__name"]
|
||||
}
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
import {
|
||||
ClassDB,
|
||||
classDiagram_default,
|
||||
classRenderer_v3_unified_default,
|
||||
styles_default
|
||||
} from "./chunk-C3EKURJB.mjs";
|
||||
import "./chunk-SXA26SXQ.mjs";
|
||||
import "./chunk-CIYSR3OL.mjs";
|
||||
import "./chunk-U2CUWHSV.mjs";
|
||||
import "./chunk-FDRWAT7V.mjs";
|
||||
import "./chunk-GQXX6INY.mjs";
|
||||
import "./chunk-3ENLOZB5.mjs";
|
||||
import "./chunk-UK2JF6A5.mjs";
|
||||
import "./chunk-C7LX3TON.mjs";
|
||||
import "./chunk-VMH3YNCZ.mjs";
|
||||
import "./chunk-ESVDSNFU.mjs";
|
||||
import "./chunk-D2KOLKXV.mjs";
|
||||
import "./chunk-7XTQR4JX.mjs";
|
||||
import "./chunk-5FJ6MPNB.mjs";
|
||||
import "./chunk-3OTVAOVH.mjs";
|
||||
import "./chunk-NCW2MGAP.mjs";
|
||||
import "./chunk-GRVEB7DL.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/class/classDiagram.ts
|
||||
var diagram = {
|
||||
parser: classDiagram_default,
|
||||
get db() {
|
||||
return new ClassDB();
|
||||
},
|
||||
renderer: classRenderer_v3_unified_default,
|
||||
styles: styles_default,
|
||||
init: /* @__PURE__ */ __name((cnf) => {
|
||||
if (!cnf.class) {
|
||||
cnf.class = {};
|
||||
}
|
||||
cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
|
||||
}, "init")
|
||||
};
|
||||
export {
|
||||
diagram
|
||||
};
|
||||
Generated
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/diagrams/class/classDiagram.ts"],
|
||||
"sourcesContent": ["import type { DiagramDefinition } from '../../diagram-api/types.js';\n// @ts-ignore: JISON doesn't support types\nimport parser from './parser/classDiagram.jison';\nimport { ClassDB } from './classDb.js';\nimport styles from './styles.js';\nimport renderer from './classRenderer-v3-unified.js';\n\nexport const diagram: DiagramDefinition = {\n parser,\n get db() {\n return new ClassDB();\n },\n renderer,\n styles,\n init: (cnf) => {\n if (!cnf.class) {\n cnf.class = {};\n }\n cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;\n },\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,UAA6B;AAAA,EACxC;AAAA,EACA,IAAI,KAAK;AACP,WAAO,IAAI,QAAQ;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM,wBAAC,QAAQ;AACb,QAAI,CAAC,IAAI,OAAO;AACd,UAAI,QAAQ,CAAC;AAAA,IACf;AACA,QAAI,MAAM,sBAAsB,IAAI;AAAA,EACtC,GALM;AAMR;",
|
||||
"names": []
|
||||
}
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
import {
|
||||
ClassDB,
|
||||
classDiagram_default,
|
||||
classRenderer_v3_unified_default,
|
||||
styles_default
|
||||
} from "./chunk-C3EKURJB.mjs";
|
||||
import "./chunk-SXA26SXQ.mjs";
|
||||
import "./chunk-CIYSR3OL.mjs";
|
||||
import "./chunk-U2CUWHSV.mjs";
|
||||
import "./chunk-FDRWAT7V.mjs";
|
||||
import "./chunk-GQXX6INY.mjs";
|
||||
import "./chunk-3ENLOZB5.mjs";
|
||||
import "./chunk-UK2JF6A5.mjs";
|
||||
import "./chunk-C7LX3TON.mjs";
|
||||
import "./chunk-VMH3YNCZ.mjs";
|
||||
import "./chunk-ESVDSNFU.mjs";
|
||||
import "./chunk-D2KOLKXV.mjs";
|
||||
import "./chunk-7XTQR4JX.mjs";
|
||||
import "./chunk-5FJ6MPNB.mjs";
|
||||
import "./chunk-3OTVAOVH.mjs";
|
||||
import "./chunk-NCW2MGAP.mjs";
|
||||
import "./chunk-GRVEB7DL.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/class/classDiagram-v2.ts
|
||||
var diagram = {
|
||||
parser: classDiagram_default,
|
||||
get db() {
|
||||
return new ClassDB();
|
||||
},
|
||||
renderer: classRenderer_v3_unified_default,
|
||||
styles: styles_default,
|
||||
init: /* @__PURE__ */ __name((cnf) => {
|
||||
if (!cnf.class) {
|
||||
cnf.class = {};
|
||||
}
|
||||
cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
|
||||
}, "init")
|
||||
};
|
||||
export {
|
||||
diagram
|
||||
};
|
||||
Generated
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": ["../../../src/diagrams/class/classDiagram-v2.ts"],
|
||||
"sourcesContent": ["import type { DiagramDefinition } from '../../diagram-api/types.js';\n// @ts-ignore: JISON doesn't support types\nimport parser from './parser/classDiagram.jison';\nimport { ClassDB } from './classDb.js';\nimport styles from './styles.js';\nimport renderer from './classRenderer-v3-unified.js';\n\nexport const diagram: DiagramDefinition = {\n parser,\n get db() {\n return new ClassDB();\n },\n renderer,\n styles,\n init: (cnf) => {\n if (!cnf.class) {\n cnf.class = {};\n }\n cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;\n },\n};\n"],
|
||||
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,UAA6B;AAAA,EACxC;AAAA,EACA,IAAI,KAAK;AACP,WAAO,IAAI,QAAQ;AAAA,EACrB;AAAA,EACA;AAAA,EACA;AAAA,EACA,MAAM,wBAAC,QAAQ;AACb,QAAI,CAAC,IAAI,OAAO;AACd,UAAI,QAAQ,CAAC;AAAA,IACf;AACA,QAAI,MAAM,sBAAsB,IAAI;AAAA,EACtC,GALM;AAMR;",
|
||||
"names": []
|
||||
}
|
||||
+5063
File diff suppressed because it is too large
Load Diff
Generated
Vendored
+7
File diff suppressed because one or more lines are too long
+744
@@ -0,0 +1,744 @@
|
||||
import {
|
||||
layout
|
||||
} from "./chunk-6JEIXYVA.mjs";
|
||||
import {
|
||||
Graph
|
||||
} from "./chunk-KACY6BU5.mjs";
|
||||
import {
|
||||
clear as clear2,
|
||||
insertEdge,
|
||||
insertEdgeLabel,
|
||||
markers_default,
|
||||
positionEdgeLabel
|
||||
} from "./chunk-3ENLOZB5.mjs";
|
||||
import "./chunk-UK2JF6A5.mjs";
|
||||
import {
|
||||
clear,
|
||||
clear2 as clear3,
|
||||
insertCluster,
|
||||
insertNode,
|
||||
positionNode,
|
||||
setNodeElem,
|
||||
updateNodeBounds
|
||||
} from "./chunk-C7LX3TON.mjs";
|
||||
import "./chunk-VMH3YNCZ.mjs";
|
||||
import {
|
||||
getSubGraphTitleMargins
|
||||
} from "./chunk-ESVDSNFU.mjs";
|
||||
import "./chunk-D2KOLKXV.mjs";
|
||||
import "./chunk-7XTQR4JX.mjs";
|
||||
import "./chunk-5FJ6MPNB.mjs";
|
||||
import "./chunk-3OTVAOVH.mjs";
|
||||
import {
|
||||
getConfig2 as getConfig
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
log
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import {
|
||||
clone_default,
|
||||
isUndefined_default,
|
||||
map_default
|
||||
} from "./chunk-MFRUYFWM.mjs";
|
||||
import "./chunk-UKL4YMJ2.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/json.js
|
||||
function write(g) {
|
||||
var json = {
|
||||
options: {
|
||||
directed: g.isDirected(),
|
||||
multigraph: g.isMultigraph(),
|
||||
compound: g.isCompound()
|
||||
},
|
||||
nodes: writeNodes(g),
|
||||
edges: writeEdges(g)
|
||||
};
|
||||
if (!isUndefined_default(g.graph())) {
|
||||
json.value = clone_default(g.graph());
|
||||
}
|
||||
return json;
|
||||
}
|
||||
__name(write, "write");
|
||||
function writeNodes(g) {
|
||||
return map_default(g.nodes(), function(v) {
|
||||
var nodeValue = g.node(v);
|
||||
var parent = g.parent(v);
|
||||
var node = { v };
|
||||
if (!isUndefined_default(nodeValue)) {
|
||||
node.value = nodeValue;
|
||||
}
|
||||
if (!isUndefined_default(parent)) {
|
||||
node.parent = parent;
|
||||
}
|
||||
return node;
|
||||
});
|
||||
}
|
||||
__name(writeNodes, "writeNodes");
|
||||
function writeEdges(g) {
|
||||
return map_default(g.edges(), function(e) {
|
||||
var edgeValue = g.edge(e);
|
||||
var edge = { v: e.v, w: e.w };
|
||||
if (!isUndefined_default(e.name)) {
|
||||
edge.name = e.name;
|
||||
}
|
||||
if (!isUndefined_default(edgeValue)) {
|
||||
edge.value = edgeValue;
|
||||
}
|
||||
return edge;
|
||||
});
|
||||
}
|
||||
__name(writeEdges, "writeEdges");
|
||||
|
||||
// src/rendering-util/layout-algorithms/dagre/mermaid-graphlib.js
|
||||
var clusterDb = /* @__PURE__ */ new Map();
|
||||
var descendants = /* @__PURE__ */ new Map();
|
||||
var parents = /* @__PURE__ */ new Map();
|
||||
var clear4 = /* @__PURE__ */ __name(() => {
|
||||
descendants.clear();
|
||||
parents.clear();
|
||||
clusterDb.clear();
|
||||
}, "clear");
|
||||
var isDescendant = /* @__PURE__ */ __name((id, ancestorId) => {
|
||||
const ancestorDescendants = descendants.get(ancestorId) || [];
|
||||
log.trace("In isDescendant", ancestorId, " ", id, " = ", ancestorDescendants.includes(id));
|
||||
return ancestorDescendants.includes(id);
|
||||
}, "isDescendant");
|
||||
var edgeInCluster = /* @__PURE__ */ __name((edge, clusterId) => {
|
||||
const clusterDescendants = descendants.get(clusterId) || [];
|
||||
log.info("Descendants of ", clusterId, " is ", clusterDescendants);
|
||||
log.info("Edge is ", edge);
|
||||
if (edge.v === clusterId || edge.w === clusterId) {
|
||||
return false;
|
||||
}
|
||||
if (!clusterDescendants) {
|
||||
log.debug("Tilt, ", clusterId, ",not in descendants");
|
||||
return false;
|
||||
}
|
||||
return clusterDescendants.includes(edge.v) || isDescendant(edge.v, clusterId) || isDescendant(edge.w, clusterId) || clusterDescendants.includes(edge.w);
|
||||
}, "edgeInCluster");
|
||||
var copy = /* @__PURE__ */ __name((clusterId, graph, newGraph, rootId) => {
|
||||
log.warn(
|
||||
"Copying children of ",
|
||||
clusterId,
|
||||
"root",
|
||||
rootId,
|
||||
"data",
|
||||
graph.node(clusterId),
|
||||
rootId
|
||||
);
|
||||
const nodes = graph.children(clusterId) || [];
|
||||
if (clusterId !== rootId) {
|
||||
nodes.push(clusterId);
|
||||
}
|
||||
log.warn("Copying (nodes) clusterId", clusterId, "nodes", nodes);
|
||||
nodes.forEach((node) => {
|
||||
if (graph.children(node).length > 0) {
|
||||
copy(node, graph, newGraph, rootId);
|
||||
} else {
|
||||
const data = graph.node(node);
|
||||
log.info("cp ", node, " to ", rootId, " with parent ", clusterId);
|
||||
newGraph.setNode(node, data);
|
||||
if (rootId !== graph.parent(node)) {
|
||||
log.warn("Setting parent", node, graph.parent(node));
|
||||
newGraph.setParent(node, graph.parent(node));
|
||||
}
|
||||
if (clusterId !== rootId && node !== clusterId) {
|
||||
log.debug("Setting parent", node, clusterId);
|
||||
newGraph.setParent(node, clusterId);
|
||||
} else {
|
||||
log.info("In copy ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId);
|
||||
log.debug(
|
||||
"Not Setting parent for node=",
|
||||
node,
|
||||
"cluster!==rootId",
|
||||
clusterId !== rootId,
|
||||
"node!==clusterId",
|
||||
node !== clusterId
|
||||
);
|
||||
}
|
||||
const edges = graph.edges(node);
|
||||
log.debug("Copying Edges", edges);
|
||||
edges.forEach((edge) => {
|
||||
log.info("Edge", edge);
|
||||
const data2 = graph.edge(edge.v, edge.w, edge.name);
|
||||
log.info("Edge data", data2, rootId);
|
||||
try {
|
||||
if (edgeInCluster(edge, rootId)) {
|
||||
log.info("Copying as ", edge.v, edge.w, data2, edge.name);
|
||||
newGraph.setEdge(edge.v, edge.w, data2, edge.name);
|
||||
log.info("newGraph edges ", newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
|
||||
} else {
|
||||
log.info(
|
||||
"Skipping copy of edge ",
|
||||
edge.v,
|
||||
"-->",
|
||||
edge.w,
|
||||
" rootId: ",
|
||||
rootId,
|
||||
" clusterId:",
|
||||
clusterId
|
||||
);
|
||||
}
|
||||
} catch (e) {
|
||||
log.error(e);
|
||||
}
|
||||
});
|
||||
}
|
||||
log.debug("Removing node", node);
|
||||
graph.removeNode(node);
|
||||
});
|
||||
}, "copy");
|
||||
var extractDescendants = /* @__PURE__ */ __name((id, graph) => {
|
||||
const children = graph.children(id);
|
||||
let res = [...children];
|
||||
for (const child of children) {
|
||||
parents.set(child, id);
|
||||
res = [...res, ...extractDescendants(child, graph)];
|
||||
}
|
||||
return res;
|
||||
}, "extractDescendants");
|
||||
var findCommonEdges = /* @__PURE__ */ __name((graph, id1, id2) => {
|
||||
const edges1 = graph.edges().filter((edge) => edge.v === id1 || edge.w === id1);
|
||||
const edges2 = graph.edges().filter((edge) => edge.v === id2 || edge.w === id2);
|
||||
const edges1Prim = edges1.map((edge) => {
|
||||
return { v: edge.v === id1 ? id2 : edge.v, w: edge.w === id1 ? id1 : edge.w };
|
||||
});
|
||||
const edges2Prim = edges2.map((edge) => {
|
||||
return { v: edge.v, w: edge.w };
|
||||
});
|
||||
const result = edges1Prim.filter((edgeIn1) => {
|
||||
return edges2Prim.some((edge) => edgeIn1.v === edge.v && edgeIn1.w === edge.w);
|
||||
});
|
||||
return result;
|
||||
}, "findCommonEdges");
|
||||
var findNonClusterChild = /* @__PURE__ */ __name((id, graph, clusterId) => {
|
||||
const children = graph.children(id);
|
||||
log.trace("Searching children of id ", id, children);
|
||||
if (children.length < 1) {
|
||||
return id;
|
||||
}
|
||||
let reserve;
|
||||
for (const child of children) {
|
||||
const _id = findNonClusterChild(child, graph, clusterId);
|
||||
const commonEdges = findCommonEdges(graph, clusterId, _id);
|
||||
if (_id) {
|
||||
if (commonEdges.length > 0) {
|
||||
reserve = _id;
|
||||
} else {
|
||||
return _id;
|
||||
}
|
||||
}
|
||||
}
|
||||
return reserve;
|
||||
}, "findNonClusterChild");
|
||||
var getAnchorId = /* @__PURE__ */ __name((id) => {
|
||||
if (!clusterDb.has(id)) {
|
||||
return id;
|
||||
}
|
||||
if (!clusterDb.get(id).externalConnections) {
|
||||
return id;
|
||||
}
|
||||
if (clusterDb.has(id)) {
|
||||
return clusterDb.get(id).id;
|
||||
}
|
||||
return id;
|
||||
}, "getAnchorId");
|
||||
var adjustClustersAndEdges = /* @__PURE__ */ __name((graph, depth) => {
|
||||
if (!graph || depth > 10) {
|
||||
log.debug("Opting out, no graph ");
|
||||
return;
|
||||
} else {
|
||||
log.debug("Opting in, graph ");
|
||||
}
|
||||
graph.nodes().forEach(function(id) {
|
||||
const children = graph.children(id);
|
||||
if (children.length > 0) {
|
||||
log.warn(
|
||||
"Cluster identified",
|
||||
id,
|
||||
" Replacement id in edges: ",
|
||||
findNonClusterChild(id, graph, id)
|
||||
);
|
||||
descendants.set(id, extractDescendants(id, graph));
|
||||
clusterDb.set(id, { id: findNonClusterChild(id, graph, id), clusterData: graph.node(id) });
|
||||
}
|
||||
});
|
||||
graph.nodes().forEach(function(id) {
|
||||
const children = graph.children(id);
|
||||
const edges = graph.edges();
|
||||
if (children.length > 0) {
|
||||
log.debug("Cluster identified", id, descendants);
|
||||
edges.forEach((edge) => {
|
||||
const d1 = isDescendant(edge.v, id);
|
||||
const d2 = isDescendant(edge.w, id);
|
||||
if (d1 ^ d2) {
|
||||
log.warn("Edge: ", edge, " leaves cluster ", id);
|
||||
log.warn("Descendants of XXX ", id, ": ", descendants.get(id));
|
||||
clusterDb.get(id).externalConnections = true;
|
||||
}
|
||||
});
|
||||
} else {
|
||||
log.debug("Not a cluster ", id, descendants);
|
||||
}
|
||||
});
|
||||
for (let id of clusterDb.keys()) {
|
||||
const nonClusterChild = clusterDb.get(id).id;
|
||||
const parent = graph.parent(nonClusterChild);
|
||||
if (parent !== id && clusterDb.has(parent) && !clusterDb.get(parent).externalConnections) {
|
||||
clusterDb.get(id).id = parent;
|
||||
}
|
||||
}
|
||||
graph.edges().forEach(function(e) {
|
||||
const edge = graph.edge(e);
|
||||
log.warn("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
|
||||
log.warn("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(graph.edge(e)));
|
||||
let v = e.v;
|
||||
let w = e.w;
|
||||
log.warn(
|
||||
"Fix XXX",
|
||||
clusterDb,
|
||||
"ids:",
|
||||
e.v,
|
||||
e.w,
|
||||
"Translating: ",
|
||||
clusterDb.get(e.v),
|
||||
" --- ",
|
||||
clusterDb.get(e.w)
|
||||
);
|
||||
if (clusterDb.get(e.v) || clusterDb.get(e.w)) {
|
||||
log.warn("Fixing and trying - removing XXX", e.v, e.w, e.name);
|
||||
v = getAnchorId(e.v);
|
||||
w = getAnchorId(e.w);
|
||||
graph.removeEdge(e.v, e.w, e.name);
|
||||
if (v !== e.v) {
|
||||
const parent = graph.parent(v);
|
||||
clusterDb.get(parent).externalConnections = true;
|
||||
edge.fromCluster = e.v;
|
||||
}
|
||||
if (w !== e.w) {
|
||||
const parent = graph.parent(w);
|
||||
clusterDb.get(parent).externalConnections = true;
|
||||
edge.toCluster = e.w;
|
||||
}
|
||||
log.warn("Fix Replacing with XXX", v, w, e.name);
|
||||
graph.setEdge(v, w, edge, e.name);
|
||||
}
|
||||
});
|
||||
log.warn("Adjusted Graph", write(graph));
|
||||
extractor(graph, 0);
|
||||
log.trace(clusterDb);
|
||||
}, "adjustClustersAndEdges");
|
||||
var extractor = /* @__PURE__ */ __name((graph, depth) => {
|
||||
log.warn("extractor - ", depth, write(graph), graph.children("D"));
|
||||
if (depth > 10) {
|
||||
log.error("Bailing out");
|
||||
return;
|
||||
}
|
||||
let nodes = graph.nodes();
|
||||
let hasChildren = false;
|
||||
for (const node of nodes) {
|
||||
const children = graph.children(node);
|
||||
hasChildren = hasChildren || children.length > 0;
|
||||
}
|
||||
if (!hasChildren) {
|
||||
log.debug("Done, no node has children", graph.nodes());
|
||||
return;
|
||||
}
|
||||
log.debug("Nodes = ", nodes, depth);
|
||||
for (const node of nodes) {
|
||||
log.debug(
|
||||
"Extracting node",
|
||||
node,
|
||||
clusterDb,
|
||||
clusterDb.has(node) && !clusterDb.get(node).externalConnections,
|
||||
!graph.parent(node),
|
||||
graph.node(node),
|
||||
graph.children("D"),
|
||||
" Depth ",
|
||||
depth
|
||||
);
|
||||
if (!clusterDb.has(node)) {
|
||||
log.debug("Not a cluster", node, depth);
|
||||
} else if (!clusterDb.get(node).externalConnections && graph.children(node) && graph.children(node).length > 0) {
|
||||
log.warn(
|
||||
"Cluster without external connections, without a parent and with children",
|
||||
node,
|
||||
depth
|
||||
);
|
||||
const graphSettings = graph.graph();
|
||||
let dir = graphSettings.rankdir === "TB" ? "LR" : "TB";
|
||||
if (clusterDb.get(node)?.clusterData?.dir) {
|
||||
dir = clusterDb.get(node).clusterData.dir;
|
||||
log.warn("Fixing dir", clusterDb.get(node).clusterData.dir, dir);
|
||||
}
|
||||
const clusterGraph = new Graph({
|
||||
multigraph: true,
|
||||
compound: true
|
||||
}).setGraph({
|
||||
rankdir: dir,
|
||||
nodesep: 50,
|
||||
ranksep: 50,
|
||||
marginx: 8,
|
||||
marginy: 8
|
||||
}).setDefaultEdgeLabel(function() {
|
||||
return {};
|
||||
});
|
||||
log.warn("Old graph before copy", write(graph));
|
||||
copy(node, graph, clusterGraph, node);
|
||||
graph.setNode(node, {
|
||||
clusterNode: true,
|
||||
id: node,
|
||||
clusterData: clusterDb.get(node).clusterData,
|
||||
label: clusterDb.get(node).label,
|
||||
graph: clusterGraph
|
||||
});
|
||||
log.warn("New graph after copy node: (", node, ")", write(clusterGraph));
|
||||
log.debug("Old graph after copy", write(graph));
|
||||
} else {
|
||||
log.warn(
|
||||
"Cluster ** ",
|
||||
node,
|
||||
" **not meeting the criteria !externalConnections:",
|
||||
!clusterDb.get(node).externalConnections,
|
||||
" no parent: ",
|
||||
!graph.parent(node),
|
||||
" children ",
|
||||
graph.children(node) && graph.children(node).length > 0,
|
||||
graph.children("D"),
|
||||
depth
|
||||
);
|
||||
log.debug(clusterDb);
|
||||
}
|
||||
}
|
||||
nodes = graph.nodes();
|
||||
log.warn("New list of nodes", nodes);
|
||||
for (const node of nodes) {
|
||||
const data = graph.node(node);
|
||||
log.warn(" Now next level", node, data);
|
||||
if (data?.clusterNode) {
|
||||
extractor(data.graph, depth + 1);
|
||||
}
|
||||
}
|
||||
}, "extractor");
|
||||
var sorter = /* @__PURE__ */ __name((graph, nodes) => {
|
||||
if (nodes.length === 0) {
|
||||
return [];
|
||||
}
|
||||
let result = Object.assign([], nodes);
|
||||
nodes.forEach((node) => {
|
||||
const children = graph.children(node);
|
||||
const sorted = sorter(graph, children);
|
||||
result = [...result, ...sorted];
|
||||
});
|
||||
return result;
|
||||
}, "sorter");
|
||||
var sortNodesByHierarchy = /* @__PURE__ */ __name((graph) => sorter(graph, graph.children()), "sortNodesByHierarchy");
|
||||
|
||||
// src/rendering-util/layout-algorithms/dagre/index.js
|
||||
var recursiveRender = /* @__PURE__ */ __name(async (_elem, graph, diagramType, id, parentCluster, siteConfig) => {
|
||||
log.warn("Graph in recursive render:XAX", write(graph), parentCluster);
|
||||
const dir = graph.graph().rankdir;
|
||||
log.trace("Dir in recursive render - dir:", dir);
|
||||
const elem = _elem.insert("g").attr("class", "root");
|
||||
if (!graph.nodes()) {
|
||||
log.info("No nodes found for", graph);
|
||||
} else {
|
||||
log.info("Recursive render XXX", graph.nodes());
|
||||
}
|
||||
if (graph.edges().length > 0) {
|
||||
log.info("Recursive edges", graph.edge(graph.edges()[0]));
|
||||
}
|
||||
const clusters = elem.insert("g").attr("class", "clusters");
|
||||
const edgePaths = elem.insert("g").attr("class", "edgePaths");
|
||||
const edgeLabels = elem.insert("g").attr("class", "edgeLabels");
|
||||
const nodes = elem.insert("g").attr("class", "nodes");
|
||||
await Promise.all(
|
||||
graph.nodes().map(async function(v) {
|
||||
const node = graph.node(v);
|
||||
if (parentCluster !== void 0) {
|
||||
const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
|
||||
log.trace(
|
||||
"Setting data for parent cluster XXX\n Node.id = ",
|
||||
v,
|
||||
"\n data=",
|
||||
data.height,
|
||||
"\nParent cluster",
|
||||
parentCluster.height
|
||||
);
|
||||
graph.setNode(parentCluster.id, data);
|
||||
if (!graph.parent(v)) {
|
||||
log.trace("Setting parent", v, parentCluster.id);
|
||||
graph.setParent(v, parentCluster.id, data);
|
||||
}
|
||||
}
|
||||
log.info("(Insert) Node XXX" + v + ": " + JSON.stringify(graph.node(v)));
|
||||
if (node?.clusterNode) {
|
||||
log.info("Cluster identified XBX", v, node.width, graph.node(v));
|
||||
const { ranksep, nodesep } = graph.graph();
|
||||
node.graph.setGraph({
|
||||
...node.graph.graph(),
|
||||
ranksep: ranksep + 25,
|
||||
nodesep
|
||||
});
|
||||
const o = await recursiveRender(
|
||||
nodes,
|
||||
node.graph,
|
||||
diagramType,
|
||||
id,
|
||||
graph.node(v),
|
||||
siteConfig
|
||||
);
|
||||
const newEl = o.elem;
|
||||
updateNodeBounds(node, newEl);
|
||||
node.diff = o.diff || 0;
|
||||
log.info(
|
||||
"New compound node after recursive render XAX",
|
||||
v,
|
||||
"width",
|
||||
// node,
|
||||
node.width,
|
||||
"height",
|
||||
node.height
|
||||
// node.x,
|
||||
// node.y
|
||||
);
|
||||
setNodeElem(newEl, node);
|
||||
} else {
|
||||
if (graph.children(v).length > 0) {
|
||||
log.trace(
|
||||
"Cluster - the non recursive path XBX",
|
||||
v,
|
||||
node.id,
|
||||
node,
|
||||
node.width,
|
||||
"Graph:",
|
||||
graph
|
||||
);
|
||||
log.trace(findNonClusterChild(node.id, graph));
|
||||
clusterDb.set(node.id, { id: findNonClusterChild(node.id, graph), node });
|
||||
} else {
|
||||
log.trace("Node - the non recursive path XAX", v, nodes, graph.node(v), dir);
|
||||
await insertNode(nodes, graph.node(v), { config: siteConfig, dir });
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
const processEdges = /* @__PURE__ */ __name(async () => {
|
||||
const edgePromises = graph.edges().map(async function(e) {
|
||||
const edge = graph.edge(e.v, e.w, e.name);
|
||||
log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
|
||||
log.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(graph.edge(e)));
|
||||
log.info(
|
||||
"Fix",
|
||||
clusterDb,
|
||||
"ids:",
|
||||
e.v,
|
||||
e.w,
|
||||
"Translating: ",
|
||||
clusterDb.get(e.v),
|
||||
clusterDb.get(e.w)
|
||||
);
|
||||
await insertEdgeLabel(edgeLabels, edge);
|
||||
});
|
||||
await Promise.all(edgePromises);
|
||||
}, "processEdges");
|
||||
await processEdges();
|
||||
log.info("Graph before layout:", JSON.stringify(write(graph)));
|
||||
log.info("############################################# XXX");
|
||||
log.info("### Layout ### XXX");
|
||||
log.info("############################################# XXX");
|
||||
layout(graph);
|
||||
log.info("Graph after layout:", JSON.stringify(write(graph)));
|
||||
let diff = 0;
|
||||
let { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig);
|
||||
await Promise.all(
|
||||
sortNodesByHierarchy(graph).map(async function(v) {
|
||||
const node = graph.node(v);
|
||||
log.info(
|
||||
"Position XBX => " + v + ": (" + node.x,
|
||||
"," + node.y,
|
||||
") width: ",
|
||||
node.width,
|
||||
" height: ",
|
||||
node.height
|
||||
);
|
||||
if (node?.clusterNode) {
|
||||
node.y += subGraphTitleTotalMargin;
|
||||
log.info(
|
||||
"A tainted cluster node XBX1",
|
||||
v,
|
||||
node.id,
|
||||
node.width,
|
||||
node.height,
|
||||
node.x,
|
||||
node.y,
|
||||
graph.parent(v)
|
||||
);
|
||||
clusterDb.get(node.id).node = node;
|
||||
positionNode(node);
|
||||
} else {
|
||||
if (graph.children(v).length > 0) {
|
||||
log.info(
|
||||
"A pure cluster node XBX1",
|
||||
v,
|
||||
node.id,
|
||||
node.x,
|
||||
node.y,
|
||||
node.width,
|
||||
node.height,
|
||||
graph.parent(v)
|
||||
);
|
||||
node.height += subGraphTitleTotalMargin;
|
||||
graph.node(node.parentId);
|
||||
const halfPadding = node?.padding / 2 || 0;
|
||||
const labelHeight = node?.labelBBox?.height || 0;
|
||||
const offsetY = labelHeight - halfPadding || 0;
|
||||
log.debug("OffsetY", offsetY, "labelHeight", labelHeight, "halfPadding", halfPadding);
|
||||
await insertCluster(clusters, node);
|
||||
clusterDb.get(node.id).node = node;
|
||||
} else {
|
||||
const parent = graph.node(node.parentId);
|
||||
node.y += subGraphTitleTotalMargin / 2;
|
||||
log.info(
|
||||
"A regular node XBX1 - using the padding",
|
||||
node.id,
|
||||
"parent",
|
||||
node.parentId,
|
||||
node.width,
|
||||
node.height,
|
||||
node.x,
|
||||
node.y,
|
||||
"offsetY",
|
||||
node.offsetY,
|
||||
"parent",
|
||||
parent,
|
||||
parent?.offsetY,
|
||||
node
|
||||
);
|
||||
positionNode(node);
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
graph.edges().forEach(function(e) {
|
||||
const edge = graph.edge(e);
|
||||
log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(edge), edge);
|
||||
edge.points.forEach((point) => point.y += subGraphTitleTotalMargin / 2);
|
||||
const startNode = graph.node(e.v);
|
||||
var endNode = graph.node(e.w);
|
||||
const paths = insertEdge(edgePaths, edge, clusterDb, diagramType, startNode, endNode, id);
|
||||
positionEdgeLabel(edge, paths);
|
||||
});
|
||||
graph.nodes().forEach(function(v) {
|
||||
const n = graph.node(v);
|
||||
log.info(v, n.type, n.diff);
|
||||
if (n.isGroup) {
|
||||
diff = n.diff;
|
||||
}
|
||||
});
|
||||
log.warn("Returning from recursive render XAX", elem, diff);
|
||||
return { elem, diff };
|
||||
}, "recursiveRender");
|
||||
var render = /* @__PURE__ */ __name(async (data4Layout, svg) => {
|
||||
const graph = new Graph({
|
||||
multigraph: true,
|
||||
compound: true
|
||||
}).setGraph({
|
||||
rankdir: data4Layout.direction,
|
||||
nodesep: data4Layout.config?.nodeSpacing || data4Layout.config?.flowchart?.nodeSpacing || data4Layout.nodeSpacing,
|
||||
ranksep: data4Layout.config?.rankSpacing || data4Layout.config?.flowchart?.rankSpacing || data4Layout.rankSpacing,
|
||||
marginx: 8,
|
||||
marginy: 8
|
||||
}).setDefaultEdgeLabel(function() {
|
||||
return {};
|
||||
});
|
||||
const element = svg.select("g");
|
||||
markers_default(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
|
||||
clear3();
|
||||
clear2();
|
||||
clear();
|
||||
clear4();
|
||||
data4Layout.nodes.forEach((node) => {
|
||||
graph.setNode(node.id, { ...node });
|
||||
if (node.parentId) {
|
||||
graph.setParent(node.id, node.parentId);
|
||||
}
|
||||
});
|
||||
log.debug("Edges:", data4Layout.edges);
|
||||
data4Layout.edges.forEach((edge) => {
|
||||
if (edge.start === edge.end) {
|
||||
const nodeId = edge.start;
|
||||
const specialId1 = nodeId + "---" + nodeId + "---1";
|
||||
const specialId2 = nodeId + "---" + nodeId + "---2";
|
||||
const node = graph.node(nodeId);
|
||||
graph.setNode(specialId1, {
|
||||
domId: specialId1,
|
||||
id: specialId1,
|
||||
parentId: node.parentId,
|
||||
labelStyle: "",
|
||||
label: "",
|
||||
padding: 0,
|
||||
shape: "labelRect",
|
||||
// shape: 'rect',
|
||||
style: "",
|
||||
width: 10,
|
||||
height: 10
|
||||
});
|
||||
graph.setParent(specialId1, node.parentId);
|
||||
graph.setNode(specialId2, {
|
||||
domId: specialId2,
|
||||
id: specialId2,
|
||||
parentId: node.parentId,
|
||||
labelStyle: "",
|
||||
padding: 0,
|
||||
// shape: 'rect',
|
||||
shape: "labelRect",
|
||||
label: "",
|
||||
style: "",
|
||||
width: 10,
|
||||
height: 10
|
||||
});
|
||||
graph.setParent(specialId2, node.parentId);
|
||||
const edge1 = structuredClone(edge);
|
||||
const edgeMid = structuredClone(edge);
|
||||
const edge2 = structuredClone(edge);
|
||||
edge1.label = "";
|
||||
edge1.arrowTypeEnd = "none";
|
||||
edge1.id = nodeId + "-cyclic-special-1";
|
||||
edgeMid.arrowTypeStart = "none";
|
||||
edgeMid.arrowTypeEnd = "none";
|
||||
edgeMid.id = nodeId + "-cyclic-special-mid";
|
||||
edge2.label = "";
|
||||
if (node.isGroup) {
|
||||
edge1.fromCluster = nodeId;
|
||||
edge2.toCluster = nodeId;
|
||||
}
|
||||
edge2.id = nodeId + "-cyclic-special-2";
|
||||
edge2.arrowTypeStart = "none";
|
||||
graph.setEdge(nodeId, specialId1, edge1, nodeId + "-cyclic-special-0");
|
||||
graph.setEdge(specialId1, specialId2, edgeMid, nodeId + "-cyclic-special-1");
|
||||
graph.setEdge(specialId2, nodeId, edge2, nodeId + "-cyc<lic-special-2");
|
||||
} else {
|
||||
graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
|
||||
}
|
||||
});
|
||||
log.warn("Graph at first:", JSON.stringify(write(graph)));
|
||||
adjustClustersAndEdges(graph);
|
||||
log.warn("Graph after XAX:", JSON.stringify(write(graph)));
|
||||
const siteConfig = getConfig();
|
||||
await recursiveRender(
|
||||
element,
|
||||
graph,
|
||||
data4Layout.type,
|
||||
data4Layout.diagramId,
|
||||
void 0,
|
||||
siteConfig
|
||||
);
|
||||
}, "render");
|
||||
export {
|
||||
render
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+353
@@ -0,0 +1,353 @@
|
||||
import {
|
||||
populateCommonDb
|
||||
} from "./chunk-WASTHULE.mjs";
|
||||
import {
|
||||
parse
|
||||
} from "./chunk-COTS6TSK.mjs";
|
||||
import "./chunk-7TV4ZQ6C.mjs";
|
||||
import "./chunk-RPUGE2OU.mjs";
|
||||
import "./chunk-TQNTULNW.mjs";
|
||||
import "./chunk-P6XZ56Y6.mjs";
|
||||
import "./chunk-ZJYGCH2D.mjs";
|
||||
import "./chunk-Q6KCKTBH.mjs";
|
||||
import "./chunk-7XTPNGWE.mjs";
|
||||
import "./chunk-FKWWLAQO.mjs";
|
||||
import {
|
||||
selectSvgElement
|
||||
} from "./chunk-2CD2RWVO.mjs";
|
||||
import {
|
||||
cleanAndMerge
|
||||
} from "./chunk-5FJ6MPNB.mjs";
|
||||
import "./chunk-3OTVAOVH.mjs";
|
||||
import {
|
||||
clear,
|
||||
configureSvgSize,
|
||||
defaultConfig_default,
|
||||
getAccDescription,
|
||||
getAccTitle,
|
||||
getConfig,
|
||||
getDiagramTitle,
|
||||
getThemeVariables,
|
||||
setAccDescription,
|
||||
setAccTitle,
|
||||
setDiagramTitle
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
log
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import "./chunk-BPXICT63.mjs";
|
||||
import "./chunk-WEB62QT6.mjs";
|
||||
import "./chunk-MFRUYFWM.mjs";
|
||||
import "./chunk-UKL4YMJ2.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/radar/db.ts
|
||||
var defaultOptions = {
|
||||
showLegend: true,
|
||||
ticks: 5,
|
||||
max: null,
|
||||
min: 0,
|
||||
graticule: "circle"
|
||||
};
|
||||
var defaultRadarData = {
|
||||
axes: [],
|
||||
curves: [],
|
||||
options: defaultOptions
|
||||
};
|
||||
var data = structuredClone(defaultRadarData);
|
||||
var DEFAULT_RADAR_CONFIG = defaultConfig_default.radar;
|
||||
var getConfig2 = /* @__PURE__ */ __name(() => {
|
||||
const config = cleanAndMerge({
|
||||
...DEFAULT_RADAR_CONFIG,
|
||||
...getConfig().radar
|
||||
});
|
||||
return config;
|
||||
}, "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 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
|
||||
};
|
||||
}, "setOptions");
|
||||
var clear2 = /* @__PURE__ */ __name(() => {
|
||||
clear();
|
||||
data = structuredClone(defaultRadarData);
|
||||
}, "clear");
|
||||
var db = {
|
||||
getAxes,
|
||||
getCurves,
|
||||
getOptions,
|
||||
setAxes,
|
||||
setCurves,
|
||||
setOptions,
|
||||
getConfig: getConfig2,
|
||||
clear: clear2,
|
||||
setAccTitle,
|
||||
getAccTitle,
|
||||
setDiagramTitle,
|
||||
getDiagramTitle,
|
||||
getAccDescription,
|
||||
setAccDescription
|
||||
};
|
||||
|
||||
// src/diagrams/radar/parser.ts
|
||||
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")
|
||||
};
|
||||
|
||||
// src/diagrams/radar/renderer.ts
|
||||
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 svg = selectSvgElement(id);
|
||||
const g = drawFrame(svg, 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}`);
|
||||
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;
|
||||
const x = r * Math.cos(angle);
|
||||
const y = r * Math.sin(angle);
|
||||
return `${x},${y}`;
|
||||
}).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;
|
||||
g.append("line").attr("x1", 0).attr("y1", 0).attr("x2", radius * config.axisScaleFactor * Math.cos(angle)).attr("y2", radius * config.axisScaleFactor * Math.sin(angle)).attr("class", "radarAxisLine");
|
||||
g.append("text").text(label).attr("x", radius * config.axisLabelFactor * Math.cos(angle)).attr("y", radius * config.axisLabelFactor * Math.sin(angle)).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);
|
||||
const x = r * Math.cos(angle);
|
||||
const y = r * Math.sin(angle);
|
||||
return { x, y };
|
||||
});
|
||||
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) {
|
||||
const clippedValue = Math.min(Math.max(value, minValue), maxValue);
|
||||
return radius * (clippedValue - 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 };
|
||||
|
||||
// src/diagrams/radar/styles.ts
|
||||
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 defaultThemeVariables = getThemeVariables();
|
||||
const currentConfig = getConfig();
|
||||
const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
|
||||
const radarOptions = cleanAndMerge(themeVariables.radar, radar);
|
||||
return { themeVariables, radarOptions };
|
||||
}, "buildRadarStyleOptions");
|
||||
var 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 {
|
||||
dominant-baseline: middle;
|
||||
text-anchor: middle;
|
||||
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");
|
||||
|
||||
// src/diagrams/radar/diagram.ts
|
||||
var diagram = {
|
||||
parser,
|
||||
db,
|
||||
renderer,
|
||||
styles
|
||||
};
|
||||
export {
|
||||
diagram
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
+588
@@ -0,0 +1,588 @@
|
||||
import {
|
||||
populateCommonDb
|
||||
} from "./chunk-WASTHULE.mjs";
|
||||
import {
|
||||
parse
|
||||
} from "./chunk-COTS6TSK.mjs";
|
||||
import "./chunk-7TV4ZQ6C.mjs";
|
||||
import "./chunk-RPUGE2OU.mjs";
|
||||
import "./chunk-TQNTULNW.mjs";
|
||||
import "./chunk-P6XZ56Y6.mjs";
|
||||
import "./chunk-ZJYGCH2D.mjs";
|
||||
import "./chunk-Q6KCKTBH.mjs";
|
||||
import "./chunk-7XTPNGWE.mjs";
|
||||
import "./chunk-FKWWLAQO.mjs";
|
||||
import {
|
||||
selectSvgElement
|
||||
} from "./chunk-2CD2RWVO.mjs";
|
||||
import {
|
||||
setupViewPortForSVG
|
||||
} from "./chunk-FDRWAT7V.mjs";
|
||||
import {
|
||||
isLabelStyle,
|
||||
styles2String
|
||||
} from "./chunk-VMH3YNCZ.mjs";
|
||||
import {
|
||||
cleanAndMerge
|
||||
} from "./chunk-5FJ6MPNB.mjs";
|
||||
import "./chunk-3OTVAOVH.mjs";
|
||||
import {
|
||||
clear,
|
||||
configureSvgSize,
|
||||
defaultConfig_default,
|
||||
getAccDescription,
|
||||
getAccTitle,
|
||||
getConfig,
|
||||
getDiagramTitle,
|
||||
getThemeVariables,
|
||||
setAccDescription,
|
||||
setAccTitle,
|
||||
setDiagramTitle
|
||||
} from "./chunk-NCW2MGAP.mjs";
|
||||
import {
|
||||
format,
|
||||
hierarchy,
|
||||
log,
|
||||
ordinal,
|
||||
select_default,
|
||||
treemap_default
|
||||
} from "./chunk-GRVEB7DL.mjs";
|
||||
import "./chunk-BPXICT63.mjs";
|
||||
import "./chunk-WEB62QT6.mjs";
|
||||
import "./chunk-MFRUYFWM.mjs";
|
||||
import "./chunk-UKL4YMJ2.mjs";
|
||||
import "./chunk-3QJOF6JT.mjs";
|
||||
import {
|
||||
__name
|
||||
} from "./chunk-FQFHLQFH.mjs";
|
||||
|
||||
// src/diagrams/treemap/db.ts
|
||||
var TreeMapDB = class {
|
||||
constructor() {
|
||||
this.nodes = [];
|
||||
this.levels = /* @__PURE__ */ new Map();
|
||||
this.outerNodes = [];
|
||||
this.classes = /* @__PURE__ */ new Map();
|
||||
this.setAccTitle = setAccTitle;
|
||||
this.getAccTitle = getAccTitle;
|
||||
this.setDiagramTitle = setDiagramTitle;
|
||||
this.getDiagramTitle = getDiagramTitle;
|
||||
this.getAccDescription = getAccDescription;
|
||||
this.setAccDescription = setAccDescription;
|
||||
}
|
||||
static {
|
||||
__name(this, "TreeMapDB");
|
||||
}
|
||||
getNodes() {
|
||||
return this.nodes;
|
||||
}
|
||||
getConfig() {
|
||||
const defaultConfig = defaultConfig_default;
|
||||
const userConfig = getConfig();
|
||||
return cleanAndMerge({
|
||||
...defaultConfig.treemap,
|
||||
...userConfig.treemap ?? {}
|
||||
});
|
||||
}
|
||||
addNode(node, level) {
|
||||
this.nodes.push(node);
|
||||
this.levels.set(node, level);
|
||||
if (level === 0) {
|
||||
this.outerNodes.push(node);
|
||||
this.root ??= node;
|
||||
}
|
||||
}
|
||||
getRoot() {
|
||||
return { name: "", children: this.outerNodes };
|
||||
}
|
||||
addClass(id, _style) {
|
||||
const styleClass = this.classes.get(id) ?? { id, styles: [], textStyles: [] };
|
||||
const styles = _style.replace(/\\,/g, "\xA7\xA7\xA7").replace(/,/g, ";").replace(/§§§/g, ",").split(";");
|
||||
if (styles) {
|
||||
styles.forEach((s) => {
|
||||
if (isLabelStyle(s)) {
|
||||
if (styleClass?.textStyles) {
|
||||
styleClass.textStyles.push(s);
|
||||
} else {
|
||||
styleClass.textStyles = [s];
|
||||
}
|
||||
}
|
||||
if (styleClass?.styles) {
|
||||
styleClass.styles.push(s);
|
||||
} else {
|
||||
styleClass.styles = [s];
|
||||
}
|
||||
});
|
||||
}
|
||||
this.classes.set(id, styleClass);
|
||||
}
|
||||
getClasses() {
|
||||
return this.classes;
|
||||
}
|
||||
getStylesForClass(classSelector) {
|
||||
return this.classes.get(classSelector)?.styles ?? [];
|
||||
}
|
||||
clear() {
|
||||
clear();
|
||||
this.nodes = [];
|
||||
this.levels = /* @__PURE__ */ new Map();
|
||||
this.outerNodes = [];
|
||||
this.classes = /* @__PURE__ */ new Map();
|
||||
this.root = void 0;
|
||||
}
|
||||
};
|
||||
|
||||
// src/diagrams/treemap/utils.ts
|
||||
function buildHierarchy(items) {
|
||||
if (!items.length) {
|
||||
return [];
|
||||
}
|
||||
const root = [];
|
||||
const stack = [];
|
||||
items.forEach((item) => {
|
||||
const node = {
|
||||
name: item.name,
|
||||
children: item.type === "Leaf" ? void 0 : []
|
||||
};
|
||||
node.classSelector = item?.classSelector;
|
||||
if (item?.cssCompiledStyles) {
|
||||
node.cssCompiledStyles = item.cssCompiledStyles;
|
||||
}
|
||||
if (item.type === "Leaf" && item.value !== void 0) {
|
||||
node.value = item.value;
|
||||
}
|
||||
while (stack.length > 0 && stack[stack.length - 1].level >= item.level) {
|
||||
stack.pop();
|
||||
}
|
||||
if (stack.length === 0) {
|
||||
root.push(node);
|
||||
} else {
|
||||
const parent = stack[stack.length - 1].node;
|
||||
if (parent.children) {
|
||||
parent.children.push(node);
|
||||
} else {
|
||||
parent.children = [node];
|
||||
}
|
||||
}
|
||||
if (item.type !== "Leaf") {
|
||||
stack.push({ node, level: item.level });
|
||||
}
|
||||
});
|
||||
return root;
|
||||
}
|
||||
__name(buildHierarchy, "buildHierarchy");
|
||||
|
||||
// src/diagrams/treemap/parser.ts
|
||||
var populate = /* @__PURE__ */ __name((ast, db) => {
|
||||
populateCommonDb(ast, db);
|
||||
const items = [];
|
||||
for (const row of ast.TreemapRows ?? []) {
|
||||
if (row.$type === "ClassDefStatement") {
|
||||
db.addClass(row.className ?? "", row.styleText ?? "");
|
||||
}
|
||||
}
|
||||
for (const row of ast.TreemapRows ?? []) {
|
||||
const item = row.item;
|
||||
if (!item) {
|
||||
continue;
|
||||
}
|
||||
const level = row.indent ? parseInt(row.indent) : 0;
|
||||
const name = getItemName(item);
|
||||
const styles = item.classSelector ? db.getStylesForClass(item.classSelector) : [];
|
||||
const cssCompiledStyles = styles.length > 0 ? styles : void 0;
|
||||
const itemData = {
|
||||
level,
|
||||
name,
|
||||
type: item.$type,
|
||||
value: item.value,
|
||||
classSelector: item.classSelector,
|
||||
cssCompiledStyles
|
||||
};
|
||||
items.push(itemData);
|
||||
}
|
||||
const hierarchyNodes = buildHierarchy(items);
|
||||
const addNodesRecursively = /* @__PURE__ */ __name((nodes, level) => {
|
||||
for (const node of nodes) {
|
||||
db.addNode(node, level);
|
||||
if (node.children && node.children.length > 0) {
|
||||
addNodesRecursively(node.children, level + 1);
|
||||
}
|
||||
}
|
||||
}, "addNodesRecursively");
|
||||
addNodesRecursively(hierarchyNodes, 0);
|
||||
}, "populate");
|
||||
var getItemName = /* @__PURE__ */ __name((item) => {
|
||||
return item.name ? String(item.name) : "";
|
||||
}, "getItemName");
|
||||
var parser = {
|
||||
// @ts-expect-error - TreeMapDB is not assignable to DiagramDB
|
||||
parser: { yy: void 0 },
|
||||
parse: /* @__PURE__ */ __name(async (text) => {
|
||||
try {
|
||||
const parseFunc = parse;
|
||||
const ast = await parseFunc("treemap", text);
|
||||
log.debug("Treemap AST:", ast);
|
||||
const db = parser.parser?.yy;
|
||||
if (!(db instanceof TreeMapDB)) {
|
||||
throw new Error(
|
||||
"parser.parser?.yy was not a TreemapDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues."
|
||||
);
|
||||
}
|
||||
populate(ast, db);
|
||||
} catch (error) {
|
||||
log.error("Error parsing treemap:", error);
|
||||
throw error;
|
||||
}
|
||||
}, "parse")
|
||||
};
|
||||
|
||||
// src/diagrams/treemap/renderer.ts
|
||||
var DEFAULT_INNER_PADDING = 10;
|
||||
var SECTION_INNER_PADDING = 10;
|
||||
var SECTION_HEADER_HEIGHT = 25;
|
||||
var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
|
||||
const treemapDb = diagram2.db;
|
||||
const config = treemapDb.getConfig();
|
||||
const treemapInnerPadding = config.padding ?? DEFAULT_INNER_PADDING;
|
||||
const title = treemapDb.getDiagramTitle();
|
||||
const root = treemapDb.getRoot();
|
||||
const { themeVariables } = getConfig();
|
||||
if (!root) {
|
||||
return;
|
||||
}
|
||||
const titleHeight = title ? 30 : 0;
|
||||
const svg = selectSvgElement(id);
|
||||
const width = config.nodeWidth ? config.nodeWidth * SECTION_INNER_PADDING : 960;
|
||||
const height = config.nodeHeight ? config.nodeHeight * SECTION_INNER_PADDING : 500;
|
||||
const svgWidth = width;
|
||||
const svgHeight = height + titleHeight;
|
||||
svg.attr("viewBox", `0 0 ${svgWidth} ${svgHeight}`);
|
||||
configureSvgSize(svg, svgHeight, svgWidth, config.useMaxWidth);
|
||||
let valueFormat;
|
||||
try {
|
||||
const formatStr = config.valueFormat || ",";
|
||||
if (formatStr === "$0,0") {
|
||||
valueFormat = /* @__PURE__ */ __name((value) => "$" + format(",")(value), "valueFormat");
|
||||
} else if (formatStr.startsWith("$") && formatStr.includes(",")) {
|
||||
const precision = /\.\d+/.exec(formatStr);
|
||||
const precisionStr = precision ? precision[0] : "";
|
||||
valueFormat = /* @__PURE__ */ __name((value) => "$" + format("," + precisionStr)(value), "valueFormat");
|
||||
} else if (formatStr.startsWith("$")) {
|
||||
const restOfFormat = formatStr.substring(1);
|
||||
valueFormat = /* @__PURE__ */ __name((value) => "$" + format(restOfFormat || "")(value), "valueFormat");
|
||||
} else {
|
||||
valueFormat = format(formatStr);
|
||||
}
|
||||
} catch (error) {
|
||||
log.error("Error creating format function:", error);
|
||||
valueFormat = format(",");
|
||||
}
|
||||
const colorScale = ordinal().range([
|
||||
"transparent",
|
||||
themeVariables.cScale0,
|
||||
themeVariables.cScale1,
|
||||
themeVariables.cScale2,
|
||||
themeVariables.cScale3,
|
||||
themeVariables.cScale4,
|
||||
themeVariables.cScale5,
|
||||
themeVariables.cScale6,
|
||||
themeVariables.cScale7,
|
||||
themeVariables.cScale8,
|
||||
themeVariables.cScale9,
|
||||
themeVariables.cScale10,
|
||||
themeVariables.cScale11
|
||||
]);
|
||||
const colorScalePeer = ordinal().range([
|
||||
"transparent",
|
||||
themeVariables.cScalePeer0,
|
||||
themeVariables.cScalePeer1,
|
||||
themeVariables.cScalePeer2,
|
||||
themeVariables.cScalePeer3,
|
||||
themeVariables.cScalePeer4,
|
||||
themeVariables.cScalePeer5,
|
||||
themeVariables.cScalePeer6,
|
||||
themeVariables.cScalePeer7,
|
||||
themeVariables.cScalePeer8,
|
||||
themeVariables.cScalePeer9,
|
||||
themeVariables.cScalePeer10,
|
||||
themeVariables.cScalePeer11
|
||||
]);
|
||||
const colorScaleLabel = ordinal().range([
|
||||
themeVariables.cScaleLabel0,
|
||||
themeVariables.cScaleLabel1,
|
||||
themeVariables.cScaleLabel2,
|
||||
themeVariables.cScaleLabel3,
|
||||
themeVariables.cScaleLabel4,
|
||||
themeVariables.cScaleLabel5,
|
||||
themeVariables.cScaleLabel6,
|
||||
themeVariables.cScaleLabel7,
|
||||
themeVariables.cScaleLabel8,
|
||||
themeVariables.cScaleLabel9,
|
||||
themeVariables.cScaleLabel10,
|
||||
themeVariables.cScaleLabel11
|
||||
]);
|
||||
if (title) {
|
||||
svg.append("text").attr("x", svgWidth / 2).attr("y", titleHeight / 2).attr("class", "treemapTitle").attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(title);
|
||||
}
|
||||
const g = svg.append("g").attr("transform", `translate(0, ${titleHeight})`).attr("class", "treemapContainer");
|
||||
const hierarchyRoot = hierarchy(root).sum((d) => d.value ?? 0).sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
|
||||
const treemapLayout = treemap_default().size([width, height]).paddingTop(
|
||||
(d) => d.children && d.children.length > 0 ? SECTION_HEADER_HEIGHT + SECTION_INNER_PADDING : 0
|
||||
).paddingInner(treemapInnerPadding).paddingLeft((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingRight((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).paddingBottom((d) => d.children && d.children.length > 0 ? SECTION_INNER_PADDING : 0).round(true);
|
||||
const treemapData = treemapLayout(hierarchyRoot);
|
||||
const branchNodes = treemapData.descendants().filter((d) => d.children && d.children.length > 0);
|
||||
const sections = g.selectAll(".treemapSection").data(branchNodes).enter().append("g").attr("class", "treemapSection").attr("transform", (d) => `translate(${d.x0},${d.y0})`);
|
||||
sections.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", SECTION_HEADER_HEIGHT).attr("class", "treemapSectionHeader").attr("fill", "none").attr("fill-opacity", 0.6).attr("stroke-width", 0.6).attr("style", (d) => {
|
||||
if (d.depth === 0) {
|
||||
return "display: none;";
|
||||
}
|
||||
return "";
|
||||
});
|
||||
sections.append("clipPath").attr("id", (_d, i) => `clip-section-${id}-${i}`).append("rect").attr("width", (d) => Math.max(0, d.x1 - d.x0 - 12)).attr("height", SECTION_HEADER_HEIGHT);
|
||||
sections.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", (d) => d.y1 - d.y0).attr("class", (_d, i) => {
|
||||
return `treemapSection section${i}`;
|
||||
}).attr("fill", (d) => colorScale(d.data.name)).attr("fill-opacity", 0.6).attr("stroke", (d) => colorScalePeer(d.data.name)).attr("stroke-width", 2).attr("stroke-opacity", 0.4).attr("style", (d) => {
|
||||
if (d.depth === 0) {
|
||||
return "display: none;";
|
||||
}
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return styles.nodeStyles + ";" + styles.borderStyles.join(";");
|
||||
});
|
||||
sections.append("text").attr("class", "treemapSectionLabel").attr("x", 6).attr("y", SECTION_HEADER_HEIGHT / 2).attr("dominant-baseline", "middle").text((d) => d.depth === 0 ? "" : d.data.name).attr("font-weight", "bold").attr("style", (d) => {
|
||||
if (d.depth === 0) {
|
||||
return "display: none;";
|
||||
}
|
||||
const labelStyles = "dominant-baseline: middle; font-size: 12px; fill:" + colorScaleLabel(d.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;";
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return labelStyles + styles.labelStyles.replace("color:", "fill:");
|
||||
}).each(function(d) {
|
||||
if (d.depth === 0) {
|
||||
return;
|
||||
}
|
||||
const self = select_default(this);
|
||||
const originalText = d.data.name;
|
||||
self.text(originalText);
|
||||
const totalHeaderWidth = d.x1 - d.x0;
|
||||
const labelXPosition = 6;
|
||||
let spaceForTextContent;
|
||||
if (config.showValues !== false && d.value) {
|
||||
const valueEndsAtXRelative = totalHeaderWidth - 10;
|
||||
const estimatedValueTextActualWidth = 30;
|
||||
const gapBetweenLabelAndValue = 10;
|
||||
const labelMustEndBeforeX = valueEndsAtXRelative - estimatedValueTextActualWidth - gapBetweenLabelAndValue;
|
||||
spaceForTextContent = labelMustEndBeforeX - labelXPosition;
|
||||
} else {
|
||||
const labelOwnRightPadding = 6;
|
||||
spaceForTextContent = totalHeaderWidth - labelXPosition - labelOwnRightPadding;
|
||||
}
|
||||
const minimumWidthToDisplay = 15;
|
||||
const actualAvailableWidth = Math.max(minimumWidthToDisplay, spaceForTextContent);
|
||||
const textNode = self.node();
|
||||
const currentTextContentLength = textNode.getComputedTextLength();
|
||||
if (currentTextContentLength > actualAvailableWidth) {
|
||||
const ellipsis = "...";
|
||||
let currentTruncatedText = originalText;
|
||||
while (currentTruncatedText.length > 0) {
|
||||
currentTruncatedText = originalText.substring(0, currentTruncatedText.length - 1);
|
||||
if (currentTruncatedText.length === 0) {
|
||||
self.text(ellipsis);
|
||||
if (textNode.getComputedTextLength() > actualAvailableWidth) {
|
||||
self.text("");
|
||||
}
|
||||
break;
|
||||
}
|
||||
self.text(currentTruncatedText + ellipsis);
|
||||
if (textNode.getComputedTextLength() <= actualAvailableWidth) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
if (config.showValues !== false) {
|
||||
sections.append("text").attr("class", "treemapSectionValue").attr("x", (d) => d.x1 - d.x0 - 10).attr("y", SECTION_HEADER_HEIGHT / 2).attr("text-anchor", "end").attr("dominant-baseline", "middle").text((d) => d.value ? valueFormat(d.value) : "").attr("font-style", "italic").attr("style", (d) => {
|
||||
if (d.depth === 0) {
|
||||
return "display: none;";
|
||||
}
|
||||
const labelStyles = "text-anchor: end; dominant-baseline: middle; font-size: 10px; fill:" + colorScaleLabel(d.data.name) + "; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;";
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return labelStyles + styles.labelStyles.replace("color:", "fill:");
|
||||
});
|
||||
}
|
||||
const leafNodes = treemapData.leaves();
|
||||
const cell = g.selectAll(".treemapLeafGroup").data(leafNodes).enter().append("g").attr("class", (d, i) => {
|
||||
return `treemapNode treemapLeafGroup leaf${i}${d.data.classSelector ? ` ${d.data.classSelector}` : ""}x`;
|
||||
}).attr("transform", (d) => `translate(${d.x0},${d.y0})`);
|
||||
cell.append("rect").attr("width", (d) => d.x1 - d.x0).attr("height", (d) => d.y1 - d.y0).attr("class", "treemapLeaf").attr("fill", (d) => {
|
||||
return d.parent ? colorScale(d.parent.data.name) : colorScale(d.data.name);
|
||||
}).attr("style", (d) => {
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return styles.nodeStyles;
|
||||
}).attr("fill-opacity", 0.3).attr("stroke", (d) => {
|
||||
return d.parent ? colorScale(d.parent.data.name) : colorScale(d.data.name);
|
||||
}).attr("stroke-width", 3);
|
||||
cell.append("clipPath").attr("id", (_d, i) => `clip-${id}-${i}`).append("rect").attr("width", (d) => Math.max(0, d.x1 - d.x0 - 4)).attr("height", (d) => Math.max(0, d.y1 - d.y0 - 4));
|
||||
const leafLabels = cell.append("text").attr("class", "treemapLabel").attr("x", (d) => (d.x1 - d.x0) / 2).attr("y", (d) => (d.y1 - d.y0) / 2).attr("style", (d) => {
|
||||
const labelStyles = "text-anchor: middle; dominant-baseline: middle; font-size: 38px;fill:" + colorScaleLabel(d.data.name) + ";";
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return labelStyles + styles.labelStyles.replace("color:", "fill:");
|
||||
}).attr("clip-path", (_d, i) => `url(#clip-${id}-${i})`).text((d) => d.data.name);
|
||||
leafLabels.each(function(d) {
|
||||
const self = select_default(this);
|
||||
const nodeWidth = d.x1 - d.x0;
|
||||
const nodeHeight = d.y1 - d.y0;
|
||||
const textNode = self.node();
|
||||
const padding = 4;
|
||||
const availableWidth = nodeWidth - 2 * padding;
|
||||
const availableHeight = nodeHeight - 2 * padding;
|
||||
if (availableWidth < 10 || availableHeight < 10) {
|
||||
self.style("display", "none");
|
||||
return;
|
||||
}
|
||||
let currentLabelFontSize = parseInt(self.style("font-size"), 10);
|
||||
const minLabelFontSize = 8;
|
||||
const originalValueRelFontSize = 28;
|
||||
const valueScaleFactor = 0.6;
|
||||
const minValueFontSize = 6;
|
||||
const spacingBetweenLabelAndValue = 2;
|
||||
while (textNode.getComputedTextLength() > availableWidth && currentLabelFontSize > minLabelFontSize) {
|
||||
currentLabelFontSize--;
|
||||
self.style("font-size", `${currentLabelFontSize}px`);
|
||||
}
|
||||
let prospectiveValueFontSize = Math.max(
|
||||
minValueFontSize,
|
||||
Math.min(originalValueRelFontSize, Math.round(currentLabelFontSize * valueScaleFactor))
|
||||
);
|
||||
let combinedHeight = currentLabelFontSize + spacingBetweenLabelAndValue + prospectiveValueFontSize;
|
||||
while (combinedHeight > availableHeight && currentLabelFontSize > minLabelFontSize) {
|
||||
currentLabelFontSize--;
|
||||
prospectiveValueFontSize = Math.max(
|
||||
minValueFontSize,
|
||||
Math.min(originalValueRelFontSize, Math.round(currentLabelFontSize * valueScaleFactor))
|
||||
);
|
||||
if (prospectiveValueFontSize < minValueFontSize && currentLabelFontSize === minLabelFontSize) {
|
||||
break;
|
||||
}
|
||||
self.style("font-size", `${currentLabelFontSize}px`);
|
||||
combinedHeight = currentLabelFontSize + spacingBetweenLabelAndValue + prospectiveValueFontSize;
|
||||
if (prospectiveValueFontSize <= minValueFontSize && combinedHeight > availableHeight) {
|
||||
}
|
||||
}
|
||||
self.style("font-size", `${currentLabelFontSize}px`);
|
||||
if (textNode.getComputedTextLength() > availableWidth || currentLabelFontSize < minLabelFontSize || availableHeight < currentLabelFontSize) {
|
||||
self.style("display", "none");
|
||||
}
|
||||
});
|
||||
if (config.showValues !== false) {
|
||||
const leafValues = cell.append("text").attr("class", "treemapValue").attr("x", (d) => (d.x1 - d.x0) / 2).attr("y", function(d) {
|
||||
return (d.y1 - d.y0) / 2;
|
||||
}).attr("style", (d) => {
|
||||
const labelStyles = "text-anchor: middle; dominant-baseline: hanging; font-size: 28px;fill:" + colorScaleLabel(d.data.name) + ";";
|
||||
const styles = styles2String({ cssCompiledStyles: d.data.cssCompiledStyles });
|
||||
return labelStyles + styles.labelStyles.replace("color:", "fill:");
|
||||
}).attr("clip-path", (_d, i) => `url(#clip-${id}-${i})`).text((d) => d.value ? valueFormat(d.value) : "");
|
||||
leafValues.each(function(d) {
|
||||
const valueTextElement = select_default(this);
|
||||
const parentCellNode = this.parentNode;
|
||||
if (!parentCellNode) {
|
||||
valueTextElement.style("display", "none");
|
||||
return;
|
||||
}
|
||||
const labelElement = select_default(parentCellNode).select(".treemapLabel");
|
||||
if (labelElement.empty() || labelElement.style("display") === "none") {
|
||||
valueTextElement.style("display", "none");
|
||||
return;
|
||||
}
|
||||
const finalLabelFontSize = parseFloat(labelElement.style("font-size"));
|
||||
const originalValueFontSize = 28;
|
||||
const valueScaleFactor = 0.6;
|
||||
const minValueFontSize = 6;
|
||||
const spacingBetweenLabelAndValue = 2;
|
||||
const actualValueFontSize = Math.max(
|
||||
minValueFontSize,
|
||||
Math.min(originalValueFontSize, Math.round(finalLabelFontSize * valueScaleFactor))
|
||||
);
|
||||
valueTextElement.style("font-size", `${actualValueFontSize}px`);
|
||||
const labelCenterY = (d.y1 - d.y0) / 2;
|
||||
const valueTopActualY = labelCenterY + finalLabelFontSize / 2 + spacingBetweenLabelAndValue;
|
||||
valueTextElement.attr("y", valueTopActualY);
|
||||
const nodeWidth = d.x1 - d.x0;
|
||||
const nodeTotalHeight = d.y1 - d.y0;
|
||||
const cellBottomPadding = 4;
|
||||
const maxValueBottomY = nodeTotalHeight - cellBottomPadding;
|
||||
const availableWidthForValue = nodeWidth - 2 * 4;
|
||||
if (valueTextElement.node().getComputedTextLength() > availableWidthForValue || valueTopActualY + actualValueFontSize > maxValueBottomY || actualValueFontSize < minValueFontSize) {
|
||||
valueTextElement.style("display", "none");
|
||||
} else {
|
||||
valueTextElement.style("display", null);
|
||||
}
|
||||
});
|
||||
}
|
||||
const diagramPadding = config.diagramPadding ?? 8;
|
||||
setupViewPortForSVG(svg, diagramPadding, "flowchart", config?.useMaxWidth || false);
|
||||
}, "draw");
|
||||
var getClasses = /* @__PURE__ */ __name(function(_text, diagramObj) {
|
||||
return diagramObj.db.getClasses();
|
||||
}, "getClasses");
|
||||
var renderer = { draw, getClasses };
|
||||
|
||||
// src/diagrams/treemap/styles.ts
|
||||
var defaultTreemapStyleOptions = {
|
||||
sectionStrokeColor: "black",
|
||||
sectionStrokeWidth: "1",
|
||||
sectionFillColor: "#efefef",
|
||||
leafStrokeColor: "black",
|
||||
leafStrokeWidth: "1",
|
||||
leafFillColor: "#efefef",
|
||||
labelFontSize: "12px",
|
||||
valueFontSize: "10px",
|
||||
titleFontSize: "14px"
|
||||
};
|
||||
var getStyles = /* @__PURE__ */ __name(({
|
||||
treemap
|
||||
} = {}) => {
|
||||
const defaultThemeVariables = getThemeVariables();
|
||||
const currentConfig = getConfig();
|
||||
const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
|
||||
const options = cleanAndMerge(defaultTreemapStyleOptions, treemap);
|
||||
const titleColor = options.titleColor ?? themeVariables.titleColor;
|
||||
const labelColor = options.labelColor ?? themeVariables.textColor;
|
||||
const valueColor = options.valueColor ?? themeVariables.textColor;
|
||||
return `
|
||||
.treemapNode.section {
|
||||
stroke: ${options.sectionStrokeColor};
|
||||
stroke-width: ${options.sectionStrokeWidth};
|
||||
fill: ${options.sectionFillColor};
|
||||
}
|
||||
.treemapNode.leaf {
|
||||
stroke: ${options.leafStrokeColor};
|
||||
stroke-width: ${options.leafStrokeWidth};
|
||||
fill: ${options.leafFillColor};
|
||||
}
|
||||
.treemapLabel {
|
||||
fill: ${labelColor};
|
||||
font-size: ${options.labelFontSize};
|
||||
}
|
||||
.treemapValue {
|
||||
fill: ${valueColor};
|
||||
font-size: ${options.valueFontSize};
|
||||
}
|
||||
.treemapTitle {
|
||||
fill: ${titleColor};
|
||||
font-size: ${options.titleFontSize};
|
||||
}
|
||||
`;
|
||||
}, "getStyles");
|
||||
var styles_default = getStyles;
|
||||
|
||||
// src/diagrams/treemap/diagram.ts
|
||||
var diagram = {
|
||||
parser,
|
||||
get db() {
|
||||
return new TreeMapDB();
|
||||
},
|
||||
renderer,
|
||||
styles: styles_default
|
||||
};
|
||||
export {
|
||||
diagram
|
||||
};
|
||||
+7
File diff suppressed because one or more lines are too long
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user