@ttsc/graph 0.26.2 → 0.28.0

package/lib/model/loadGraph.js

@@ -45,6 +45,7 @@ const typia_1 = __importDefault(require("typia"));
 const nativeExecutable_1 = require("../nativeExecutable");
 const resolveGraphBinary_1 = require("../resolveGraphBinary");
 const TtscGraphMemory_1 = require("./TtscGraphMemory");
+const publishedArtifacts_1 = require("./publishedArtifacts");
 /**
  * The dump schema version this client reads.
  *
@@ -57,8 +58,15 @@ const TtscGraphMemory_1 = require("./TtscGraphMemory");
  * protocol and has to hold it to the same number: the envelope's version and
  * the body's are independent, so a producer can speak this protocol and still
  * send a body from another schema.
+ *
+ * `scripts/assert-ttscgraph-release-candidate.cjs` reads this declaration out
+ * of this file with a regular expression, because it runs against a packaged
+ * binary in a workflow that has no reason to have built this package first.
+ * Rewriting the declaration — adding a type annotation, splitting the line —
+ * makes that script fail loudly rather than silently, and its message names
+ * this constant; update its pattern with any such change.
  */
-exports.DUMP_SCHEMA_VERSION = 6;
+exports.DUMP_SCHEMA_VERSION = 8;
 /**
  * Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
  * dump` once and loading its JSON. This is the one-shot path for direct callers
@@ -89,7 +97,19 @@ function loadGraph(options = {}) {
     let stdout;
     let stderr;
     try {
-        result = (0, node_child_process_1.spawnSync)(binary, ["dump", "--cwd", cwd, "--tsconfig", tsconfig], {
+        // Ask the project's lint install for the artifacts a citation can name
+        // before the dump runs, so the producer can resolve a documentation target
+        // into a relation rather than leaving it a token. A project with no lint
+        // install, or none that publishes, contributes no file and no claim.
+        const artifacts = (0, publishedArtifacts_1.publishArtifacts)({ cwd, tsconfig });
+        result = (0, node_child_process_1.spawnSync)(binary, [
+            "dump",
+            "--cwd",
+            cwd,
+            "--tsconfig",
+            tsconfig,
+            ...(artifacts.file === null ? [] : ["--artifacts", artifacts.file]),
+        ], {
             stdio: ["ignore", capture.stdoutFd, capture.stderrFd],
             windowsHide: true,
         });
@@ -155,10 +175,14 @@ function parseDump(json) {
             const _ip10 = input => undefined === input["enumMembers"] || Array.isArray(input["enumMembers"]) && input["enumMembers"].every(elem => "object" === typeof elem && null !== elem && _io9(elem));
             const _ip11 = input => undefined === input["objectMembers"] || Array.isArray(input["objectMembers"]) && input["objectMembers"].every(elem => "object" === typeof elem && null !== elem && _io10(elem));
             const _ip12 = input => undefined === input["decorators"] || Array.isArray(input["decorators"]) && input["decorators"].every(elem => "object" === typeof elem && null !== elem && _io11(elem));
-            const _ip13 = input => undefined === input["signature"] || "string" === typeof input["signature"];
-            const _ip14 = input => "class" === input["kind"] || "enum" === input["kind"] || "function" === input["kind"] || "interface" === input["kind"] || "method" === input["kind"] || "module" === input["kind"] || "type" === input["kind"] || "variable" === input["kind"];
-            const _ip15 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io13(input["evidence"]);
-            const _ip16 = input => undefined === input["implementation"] || "object" === typeof input["implementation"] && null !== input["implementation"] && _io13(input["implementation"]);
+            const _ip13 = input => undefined === input["docTags"] || Array.isArray(input["docTags"]) && input["docTags"].every(elem => "object" === typeof elem && null !== elem && _io13(elem));
+            const _ip14 = input => undefined === input["signature"] || "string" === typeof input["signature"];
+            const _ip15 = input => true === _iv1.has(input["kind"]);
+            const _iv1 = new Set(["class", "enum", "function", "interface", "markdown_document", "markdown_section", "method", "module", "prisma_column", "prisma_model", "prisma_relation", "swagger_operation", "type", "variable"]);
+            const _ip16 = input => undefined === input["parent"] || "string" === typeof input["parent"];
+            const _ip17 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io14(input["evidence"]);
+            const _ip18 = input => undefined === input["implementation"] || "object" === typeof input["implementation"] && null !== input["implementation"] && _io14(input["implementation"]);
+            const _iv2 = new Set(["accesses", "calls", "doc_ref", "exports", "extends", "implements", "instantiates", "overrides", "renders", "type_ref"]);
             const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".file",
@@ -212,9 +236,9 @@ function parseDump(json) {
                 path: _path + ".modifiers",
                 expected: "(Array<TtscGraphNodeModifier> | undefined)",
                 value: input["modifiers"]
-            }, _errorFactory)) && input["modifiers"].every((elem, _index21) => true === _av0.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input["modifiers"].every((elem, _index22) => true === _av0.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".modifiers[" + _index21 + "]",
+                path: _path + ".modifiers[" + _index22 + "]",
                 expected: _ae0,
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -230,9 +254,9 @@ function parseDump(json) {
                 path: _path + ".literals",
                 expected: "(Array<string> | undefined)",
                 value: input["literals"]
-            }, _errorFactory)) && input["literals"].every((elem, _index22) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input["literals"].every((elem, _index23) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".literals[" + _index22 + "]",
+                path: _path + ".literals[" + _index23 + "]",
                 expected: "string",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -246,14 +270,14 @@ function parseDump(json) {
                 path: _path + ".enumMembers",
                 expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
                 value: input["enumMembers"]
-            }, _errorFactory)) && input["enumMembers"].every((elem, _index23) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input["enumMembers"].every((elem, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".enumMembers[" + _index23 + "]",
+                path: _path + ".enumMembers[" + _index24 + "]",
                 expected: "ITtscGraphNode.IEnumMember",
                 value: elem
-            }, _errorFactory)) && _ao9(elem, _path + ".enumMembers[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao9(elem, _path + ".enumMembers[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".enumMembers[" + _index23 + "]",
+                path: _path + ".enumMembers[" + _index24 + "]",
                 expected: "ITtscGraphNode.IEnumMember",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -267,14 +291,14 @@ function parseDump(json) {
                 path: _path + ".objectMembers",
                 expected: "(Array<ITtscGraphNode.IObjectMember> | undefined)",
                 value: input["objectMembers"]
-            }, _errorFactory)) && input["objectMembers"].every((elem, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input["objectMembers"].every((elem, _index25) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".objectMembers[" + _index24 + "]",
+                path: _path + ".objectMembers[" + _index25 + "]",
                 expected: "ITtscGraphNode.IObjectMember",
                 value: elem
-            }, _errorFactory)) && _ao10(elem, _path + ".objectMembers[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao10(elem, _path + ".objectMembers[" + _index25 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".objectMembers[" + _index24 + "]",
+                path: _path + ".objectMembers[" + _index25 + "]",
                 expected: "ITtscGraphNode.IObjectMember",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -288,14 +312,14 @@ function parseDump(json) {
                 path: _path + ".decorators",
                 expected: "(Array<ITtscGraphDecorator> | undefined)",
                 value: input["decorators"]
-            }, _errorFactory)) && input["decorators"].every((elem, _index25) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input["decorators"].every((elem, _index26) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".decorators[" + _index25 + "]",
+                path: _path + ".decorators[" + _index26 + "]",
                 expected: "ITtscGraphDecorator",
                 value: elem
-            }, _errorFactory)) && _ao11(elem, _path + ".decorators[" + _index25 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao11(elem, _path + ".decorators[" + _index26 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".decorators[" + _index25 + "]",
+                path: _path + ".decorators[" + _index26 + "]",
                 expected: "ITtscGraphDecorator",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -304,40 +328,71 @@ function parseDump(json) {
                 expected: "(Array<ITtscGraphDecorator> | undefined)",
                 value: input["decorators"]
             }, _errorFactory);
-            const _ap13 = (input, _path, _exceptionable = true) => undefined === input["signature"] || "string" === typeof input["signature"] || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ap13 = (input, _path, _exceptionable = true) => undefined === input["docTags"] || (Array.isArray(input["docTags"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".docTags",
+                expected: "(Array<ITtscGraphDocTag> | undefined)",
+                value: input["docTags"]
+            }, _errorFactory)) && input["docTags"].every((elem, _index27) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".docTags[" + _index27 + "]",
+                expected: "ITtscGraphDocTag",
+                value: elem
+            }, _errorFactory)) && _ao13(elem, _path + ".docTags[" + _index27 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".docTags[" + _index27 + "]",
+                expected: "ITtscGraphDocTag",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".docTags",
+                expected: "(Array<ITtscGraphDocTag> | undefined)",
+                value: input["docTags"]
+            }, _errorFactory);
+            const _ap14 = (input, _path, _exceptionable = true) => undefined === input["signature"] || "string" === typeof input["signature"] || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".signature",
                 expected: "(string | undefined)",
                 value: input["signature"]
             }, _errorFactory);
-            const _ap14 = (input, _path, _exceptionable = true) => "class" === input["kind"] || "enum" === input["kind"] || "function" === input["kind"] || "interface" === input["kind"] || "method" === input["kind"] || "module" === input["kind"] || "type" === input["kind"] || "variable" === input["kind"] || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ap15 = (input, _path, _exceptionable = true) => true === _av1.has(input["kind"]) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".kind",
-                expected: "(\"class\" | \"enum\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"type\" | \"variable\")",
+                expected: _ae1,
                 value: input["kind"]
             }, _errorFactory);
-            const _ap15 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
+            const _av1 = new Set(["class", "enum", "function", "interface", "markdown_document", "markdown_section", "method", "module", "prisma_column", "prisma_model", "prisma_relation", "swagger_operation", "type", "variable"]);
+            const _ae1 = "(\"class\" | \"enum\" | \"function\" | \"interface\" | \"markdown_document\" | \"markdown_section\" | \"method\" | \"module\" | \"prisma_column\" | \"prisma_model\" | \"prisma_relation\" | \"swagger_operation\" | \"type\" | \"variable\")";
+            const _ap16 = (input, _path, _exceptionable = true) => undefined === input["parent"] || "string" === typeof input["parent"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".parent",
+                expected: "(string | undefined)",
+                value: input["parent"]
+            }, _errorFactory);
+            const _ap17 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".evidence",
                 expected: "(ITtscGraphSpan | undefined)",
                 value: input["evidence"]
-            }, _errorFactory)) && _ao13(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao14(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".evidence",
                 expected: "(ITtscGraphSpan | undefined)",
                 value: input["evidence"]
             }, _errorFactory);
-            const _ap16 = (input, _path, _exceptionable = true) => undefined === input["implementation"] || ("object" === typeof input["implementation"] && null !== input["implementation"] || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ap18 = (input, _path, _exceptionable = true) => undefined === input["implementation"] || ("object" === typeof input["implementation"] && null !== input["implementation"] || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".implementation",
                 expected: "(ITtscGraphSpan | undefined)",
                 value: input["implementation"]
-            }, _errorFactory)) && _ao13(input["implementation"], _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao14(input["implementation"], _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".implementation",
                 expected: "(ITtscGraphSpan | undefined)",
                 value: input["implementation"]
             }, _errorFactory);
+            const _av2 = new Set(["accesses", "calls", "doc_ref", "exports", "extends", "implements", "instantiates", "overrides", "renders", "type_ref"]);
+            const _ae2 = "(\"accesses\" | \"calls\" | \"doc_ref\" | \"exports\" | \"extends\" | \"implements\" | \"instantiates\" | \"overrides\" | \"renders\" | \"type_ref\")";
             const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".project",
@@ -363,14 +418,14 @@ function parseDump(json) {
                 path: _path + ".diagnostics",
                 expected: "Array<ITtscGraphDump.IDiagnostic>",
                 value: input.diagnostics
-            }, _errorFactory)) && input.diagnostics.every((elem, _index14) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.diagnostics.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".diagnostics[" + _index14 + "]",
+                path: _path + ".diagnostics[" + _index15 + "]",
                 expected: "ITtscGraphDump.IDiagnostic",
                 value: elem
-            }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index14 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".diagnostics[" + _index14 + "]",
+                path: _path + ".diagnostics[" + _index15 + "]",
                 expected: "ITtscGraphDump.IDiagnostic",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -383,14 +438,14 @@ function parseDump(json) {
                 path: _path + ".nodes",
                 expected: "Array<ITtscGraphDump.INode>",
                 value: input.nodes
-            }, _errorFactory)) && input.nodes.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.nodes.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".nodes[" + _index15 + "]",
+                path: _path + ".nodes[" + _index16 + "]",
                 expected: "ITtscGraphDump.INode",
                 value: elem
-            }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".nodes[" + _index15 + "]",
+                path: _path + ".nodes[" + _index16 + "]",
                 expected: "ITtscGraphDump.INode",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -403,14 +458,14 @@ function parseDump(json) {
                 path: _path + ".edges",
                 expected: "Array<ITtscGraphDump.IEdge>",
                 value: input.edges
-            }, _errorFactory)) && input.edges.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.edges.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".edges[" + _index16 + "]",
+                path: _path + ".edges[" + _index17 + "]",
                 expected: "ITtscGraphDump.IEdge",
                 value: elem
-            }, _errorFactory)) && _ao14(elem, _path + ".edges[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao15(elem, _path + ".edges[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".edges[" + _index16 + "]",
+                path: _path + ".edges[" + _index17 + "]",
                 expected: "ITtscGraphDump.IEdge",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -429,9 +484,9 @@ function parseDump(json) {
                 path: _path + ".capabilities",
                 expected: "Array<string>",
                 value: input.capabilities
-            }, _errorFactory)) && input.capabilities.every((elem, _index17) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.capabilities.every((elem, _index18) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".capabilities[" + _index17 + "]",
+                path: _path + ".capabilities[" + _index18 + "]",
                 expected: "string",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -449,6 +504,16 @@ function parseDump(json) {
                 path: _path + ".producer",
                 expected: "ITtscGraphDump.IProducer",
                 value: input.producer
+            }, _errorFactory)) && (undefined === input.artifactProducer || ("object" === typeof input.artifactProducer && null !== input.artifactProducer || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".artifactProducer",
+                expected: "(ITtscGraphDump.IProducer | undefined)",
+                value: input.artifactProducer
+            }, _errorFactory)) && _ao2(input.artifactProducer, _path + ".artifactProducer", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".artifactProducer",
+                expected: "(ITtscGraphDump.IProducer | undefined)",
+                value: input.artifactProducer
             }, _errorFactory)) && (("object" === typeof input.universe && null !== input.universe || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".universe",
@@ -464,14 +529,14 @@ function parseDump(json) {
                 path: _path + ".sources",
                 expected: "Array<ITtscGraphDump.ISourceDigest>",
                 value: input.sources
-            }, _errorFactory)) && input.sources.every((elem, _index18) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.sources.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".sources[" + _index18 + "]",
+                path: _path + ".sources[" + _index19 + "]",
                 expected: "ITtscGraphDump.ISourceDigest",
                 value: elem
-            }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index18 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".sources[" + _index18 + "]",
+                path: _path + ".sources[" + _index19 + "]",
                 expected: "ITtscGraphDump.ISourceDigest",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -490,20 +555,20 @@ function parseDump(json) {
                 path: _path + ".line",
                 expected: "(number | undefined)",
                 value: input.line
-            }, _errorFactory)) && _ap13(input, _path, true && _exceptionable);
+            }, _errorFactory)) && _ap14(input, _path, true && _exceptionable);
             const _ao11 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".arguments",
                 expected: "Array<ITtscGraphDecorator.IArgument>",
                 value: input.arguments
-            }, _errorFactory)) && input.arguments.every((elem, _index26) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.arguments.every((elem, _index28) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".arguments[" + _index26 + "]",
+                path: _path + ".arguments[" + _index28 + "]",
                 expected: "ITtscGraphDecorator.IArgument",
                 value: elem
-            }, _errorFactory)) && _ao12(elem, _path + ".arguments[" + _index26 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao12(elem, _path + ".arguments[" + _index28 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".arguments[" + _index26 + "]",
+                path: _path + ".arguments[" + _index28 + "]",
                 expected: "ITtscGraphDecorator.IArgument",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -518,7 +583,13 @@ function parseDump(json) {
                 expected: "(boolean | number | string | undefined)",
                 value: input.literal
             }, _errorFactory);
-            const _ao13 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ao13 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && (undefined === input.text || "string" === typeof input.text || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".text",
+                expected: "(string | undefined)",
+                value: input.text
+            }, _errorFactory));
+            const _ao14 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".file",
                 expected: "(string | undefined)",
@@ -544,7 +615,7 @@ function parseDump(json) {
                 expected: "(number | undefined)",
                 value: input.endCol
             }, _errorFactory));
-            const _ao14 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ao15 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".from",
                 expected: "string",
@@ -554,12 +625,12 @@ function parseDump(json) {
                 path: _path + ".to",
                 expected: "string",
                 value: input.to
-            }, _errorFactory)) && ("accesses" === input.kind || "calls" === input.kind || "exports" === input.kind || "extends" === input.kind || "implements" === input.kind || "instantiates" === input.kind || "overrides" === input.kind || "renders" === input.kind || "type_ref" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".kind",
-                expected: "(\"accesses\" | \"calls\" | \"exports\" | \"extends\" | \"implements\" | \"instantiates\" | \"overrides\" | \"renders\" | \"type_ref\")",
+                expected: _ae2,
                 value: input.kind
-            }, _errorFactory)) && _ap15(input, _path, true && _exceptionable);
+            }, _errorFactory)) && _ap17(input, _path, true && _exceptionable);
             const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.tool || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".tool",
@@ -581,14 +652,14 @@ function parseDump(json) {
                 path: _path + ".configs",
                 expected: "Array<ITtscGraphDump.IFileDigest>",
                 value: input.configs
-            }, _errorFactory)) && input.configs.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.configs.every((elem, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".configs[" + _index19 + "]",
+                path: _path + ".configs[" + _index20 + "]",
                 expected: "ITtscGraphDump.IFileDigest",
                 value: elem
-            }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".configs[" + _index19 + "]",
+                path: _path + ".configs[" + _index20 + "]",
                 expected: "ITtscGraphDump.IFileDigest",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -601,14 +672,14 @@ function parseDump(json) {
                 path: _path + ".roots",
                 expected: "Array<ITtscGraphDump.IRootFile>",
                 value: input.roots
-            }, _errorFactory)) && input.roots.every((elem, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && input.roots.every((elem, _index21) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".roots[" + _index20 + "]",
+                path: _path + ".roots[" + _index21 + "]",
                 expected: "ITtscGraphDump.IRootFile",
                 value: elem
-            }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index21 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".roots[" + _index20 + "]",
+                path: _path + ".roots[" + _index21 + "]",
                 expected: "ITtscGraphDump.IRootFile",
                 value: elem
             }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -666,27 +737,28 @@ function parseDump(json) {
                 expected: "string",
                 value: input.message
             }, _errorFactory));
-            const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap15(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable);
+            const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap15(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable) && _ap17(input, _path, true && _exceptionable) && _ap18(input, _path, true && _exceptionable);
             const _ao9 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && (undefined === input.value || "string" === typeof input.value || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".value",
                 expected: "(string | undefined)",
                 value: input.value
             }, _errorFactory));
-            const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io14(elem)));
-            const _io1 = input => "number" === typeof input.schemaVersion && (Array.isArray(input.capabilities) && input.capabilities.every(elem => "string" === typeof elem)) && ("object" === typeof input.producer && null !== input.producer && _io2(input.producer)) && ("object" === typeof input.universe && null !== input.universe && _io3(input.universe)) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
-            const _io10 = input => _ip2(input) && ("method" === input.kind || "property" === input.kind) && (undefined === input.line || "number" === typeof input.line) && _ip13(input);
+            const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io15(elem)));
+            const _io1 = input => "number" === typeof input.schemaVersion && (Array.isArray(input.capabilities) && input.capabilities.every(elem => "string" === typeof elem)) && ("object" === typeof input.producer && null !== input.producer && _io2(input.producer)) && (undefined === input.artifactProducer || "object" === typeof input.artifactProducer && null !== input.artifactProducer && _io2(input.artifactProducer)) && ("object" === typeof input.universe && null !== input.universe && _io3(input.universe)) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+            const _io10 = input => _ip2(input) && ("method" === input.kind || "property" === input.kind) && (undefined === input.line || "number" === typeof input.line) && _ip14(input);
             const _io11 = input => _ip2(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io12(elem)));
             const _io12 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
-            const _io13 = input => (undefined === input.file || "string" === typeof input.file) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol);
-            const _io14 = input => "string" === typeof input.from && "string" === typeof input.to && ("accesses" === input.kind || "calls" === input.kind || "exports" === input.kind || "extends" === input.kind || "implements" === input.kind || "instantiates" === input.kind || "overrides" === input.kind || "renders" === input.kind || "type_ref" === input.kind) && _ip15(input);
+            const _io13 = input => _ip2(input) && (undefined === input.text || "string" === typeof input.text);
+            const _io14 = input => (undefined === input.file || "string" === typeof input.file) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol);
+            const _io15 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip17(input);
             const _io2 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
             const _io3 = input => Array.isArray(input.configs) && input.configs.every(elem => "object" === typeof elem && null !== elem && _io4(elem)) && (Array.isArray(input.roots) && input.roots.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
             const _io4 = input => _ip0(input) && "string" === typeof input.digest;
             const _io5 = input => "string" === typeof input.config && _ip0(input);
             const _io6 = input => _ip0(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
             const _io7 = input => _ip0(input) && "number" === typeof input.line && "number" === typeof input.column && "number" === typeof input.code && ("error" === input.category || "warning" === input.category) && "string" === typeof input.message;
-            const _io8 = input => _ip1(input) && _ip2(input) && _ip3(input) && _ip0(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input);
+            const _io8 = input => _ip1(input) && _ip2(input) && _ip3(input) && _ip0(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input) && _ip17(input) && _ip18(input);
             const _io9 = input => _ip2(input) && (undefined === input.value || "string" === typeof input.value);
             const __is = input => "object" === typeof input && null !== input && _io0(input);
             let _errorFactory;

package/lib/model/loadGraph.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA+C;AAC/C,kDAA0B;AAE1B,0DAA6E;AAC7E,8DAA2D;AAE3D,uDAAoD;AAEpD;;;;;;;;;;;;GAYG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;;;;;GASG;AACH,mBACE,OAAO,GAWH,EAAE;IAEN,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAA,uCAAkB,EAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACtE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,qDAAqD;YACrD,+CAA+C,CAClD,CAAC;IACJ,CAAC;IACD,IAAA,mCAAgB,EAAC,MAAM,CAAC,CAAC;IAEzB,4EAA4E;IAC5E,8EAA8E;IAC9E,qEAAqE;IACrE,MAAM,OAAO,GAAG,IAAA,uCAAoB,GAAE,CAAC;IACvC,IAAI,MAAM,CAAC;IACX,IAAI,MAAc,CAAC;IACnB,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,IAAA,8BAAS,EAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;YACzE,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC;YACrD,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QACH,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,OAAO,EAAE,CAAC;IACpB,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,uCAAuC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAC7E,CAAC;IACJ,CAAC;IAED,OAAO,iCAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,mBAA0B,IAAY;IACpC,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,+CACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAuB;;;;SAEjC,KAAK,EACN,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa;QAChC,CAAC,CAAC,SAAS,CAAC;IACd,IAAI,OAAO,KAAK,QAAA,mBAAmB,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,yCACE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,EACzD,wBAAwB,MAAM,CAAC,QAAA,mBAAmB,CAAC,IAAI;YACrD,iEAAiE;YACjE,sCAAsC,CACzC,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAoC,KAAK,EAAE;IAC7C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,mDAAmD,MAAM,CACvD,QAAA,mBAAmB,CACpB,KAAK,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAC9D,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;IACJ,CAAC;AACH,CAAC"}
+{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":"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"}