@shaderfrog/core 1.3.1 → 1.3.3

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@shaderfrog/core",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Shaderfrog core",
   "type": "module",
-  "exports": {
-    "require": "./cjs/index.js",
-    "import": "./esm/index.js"
-  },
   "files": [
-    "cjs",
-    "esm"
+    "engine.d.ts",
+    "engine.js",
+    "graph",
+    "index.d.ts",
+    "index.js",
+    "plugins",
+    "strategy",
+    "util"
   ],
   "scripts": {
     "prepare": "npm run build && ./prepublish.sh",
@@ -46,7 +48,7 @@
     "lodash.groupby": "^4.6.0"
   },
   "peerDependencies": {
-    "@shaderfrog/glsl-parser": "^2.1.5",
+    "@shaderfrog/glsl-parser": "^3.0.0",
     "babylonjs": ">=4",
     "playcanvas": "^1.65.3",
     "three": ">=0.50"

package/cjs/engine.js

@@ -1,218 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectInitialEvaluatedGraphProperties = exports.convertToEngine = exports.convertNode = exports.EngineNodeType = void 0;
-var preprocessor_1 = __importDefault(require("@shaderfrog/glsl-parser/preprocessor"));
-var glsl_parser_1 = require("@shaderfrog/glsl-parser");
-var graph_types_1 = require("./graph/graph-types");
-var lodash_groupby_1 = __importDefault(require("lodash.groupby"));
-var graph_1 = require("./graph/graph");
-var evaluate_1 = require("./graph/evaluate");
-var log = function () {
-    var _a;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[32m(core)\x1b[0m'], __read(args), false));
-};
-var EngineNodeType;
-(function (EngineNodeType) {
-    EngineNodeType["toon"] = "toon";
-    EngineNodeType["phong"] = "phong";
-    EngineNodeType["physical"] = "physical";
-    EngineNodeType["shader"] = "shader";
-    EngineNodeType["binary"] = "binary";
-})(EngineNodeType = exports.EngineNodeType || (exports.EngineNodeType = {}));
-// type EdgeUpdates = { [edgeId: string]: { oldInput: string; newInput: string } };
-var convertNode = function (node, converter) {
-    log("Converting ".concat(node.name, " (").concat(node.id, ")"));
-    var preprocessed = (0, preprocessor_1.default)(node.source, {
-        preserveComments: true,
-        preserve: {
-            version: function () { return true; },
-            define: function () { return true; },
-        },
-    });
-    var ast = glsl_parser_1.parser.parse(preprocessed);
-    converter.convertAst(ast, node.stage);
-    var source = (0, glsl_parser_1.generate)(ast);
-    return __assign(__assign({}, node), { source: source });
-};
-exports.convertNode = convertNode;
-var convertToEngine = function (oldEngine, newEngine, graph) {
-    var converter = newEngine.importers[oldEngine.name];
-    if (!converter) {
-        throw new Error("The engine ".concat(newEngine.name, " has no importer for ").concat(oldEngine.name));
-    }
-    log("Attempting to convert from ".concat(newEngine.name, " to ").concat(oldEngine.name));
-    // const edgeUpdates: EdgeUpdates = {};
-    var edgesByNodeId = (0, lodash_groupby_1.default)(graph.edges, 'to');
-    var edgeUpdates = {};
-    var nodeUpdates = {};
-    graph.nodes.forEach(function (node) {
-        // Convert engine nodes
-        if (node.type in EngineNodeType) {
-            if (node.type in newEngine.constructors) {
-                var source = node;
-                nodeUpdates[source.id] = // @ts-ignore
-                    newEngine.constructors[source.type](source.id, source.name, source.position, source.config.uniforms, source.stage);
-                // Bail if no conversion
-            }
-            else {
-                throw new Error("Can't convert ".concat(oldEngine.name, " to ").concat(newEngine.name, " because ").concat(newEngine.name, " does not have a \"").concat(node.type, "\" constructor"));
-            }
-        }
-        else if (graph_types_1.NodeType.SOURCE === node.type) {
-            nodeUpdates[node.id] = (0, exports.convertNode)(node, converter);
-        }
-        // Then update input edges. We only care about engine nodes
-        if (node.type in converter.nodeInputMap) {
-            var map_1 = converter.nodeInputMap[node.type];
-            (edgesByNodeId[node.id] || []).forEach(function (edge) {
-                if (edge.input in map_1) {
-                    var mapped = map_1[edge.input];
-                    log('Converting edge', edge.input, 'to', map_1[edge.input]);
-                    edgeUpdates[edge.id] = __assign(__assign({}, edge), { input: mapped });
-                }
-                else {
-                    log('Discarding', edge.input, 'as there is no edge mapping in the', newEngine.name, 'importer');
-                    edgeUpdates[edge.id] = null;
-                }
-            });
-        }
-    });
-    graph.edges = graph.edges.reduce(function (edges, edge) {
-        if (edge.id in edgeUpdates) {
-            var res = edgeUpdates[edge.id];
-            if (res === null) {
-                return edges;
-            }
-            else {
-                return __spreadArray(__spreadArray([], __read(edges), false), [res], false);
-            }
-        }
-        return __spreadArray(__spreadArray([], __read(edges), false), [edge], false);
-    }, []);
-    graph.nodes = graph.nodes.reduce(function (nodes, node) {
-        if (node.id in nodeUpdates) {
-            var res = nodeUpdates[node.id];
-            if (res === null) {
-                return nodes;
-            }
-            else {
-                return __spreadArray(__spreadArray([], __read(nodes), false), [res], false);
-            }
-        }
-        return __spreadArray(__spreadArray([], __read(nodes), false), [node], false);
-    }, []);
-    log('Created converted graph', graph);
-    return graph;
-};
-exports.convertToEngine = convertToEngine;
-/**
- * Create the initial engine node properties for a plugin to create its initial
- * material with. This finds all engine nodes in the graph, finds all their
- * properties, evalutes them, and returns an object with initial properties to
- * set on the new plugin material, like a three.RawShaderMaterial().
- *
- * Currently only PlayCanvas uses this. It's at odds with the compileResult.dataInputs
- * code path. That path uses isDataNode() to check for inputs, which excludes
- * baked inputs. PlayCanvas requires (at least diffusesMap?) baked input properties
- * to be set to a pc.Texture() at runtime, otherwise there's an error about
- * vertex_texCoord0.
- */
-var collectInitialEvaluatedGraphProperties = function (engine, graph, defaultPropertySetting) {
-    var graphProperties = {};
-    // Get all the nodes with properties, meaning engine nodes, and the inputs
-    // for each property (property is like "diffuseMap").
-    var _a = (0, graph_1.collectNodeProperties)(graph), nodes = _a.nodes, inputs = _a.inputs;
-    Object.entries(inputs).forEach(function (_a) {
-        var _b = __read(_a, 2), nodeId = _b[0], nodeInputs = _b[1];
-        // For every node with properties... There might be mulitple if there are
-        // uniforms plugged into both frag and vertex engine nodes, which
-        var node = nodes[nodeId];
-        nodeInputs.forEach(function (i) {
-            // Cast this to an input with a property specified on it, which the
-            // predicate search enforces
-            var input = i;
-            var edge = graph.edges.find(function (_a) {
-                var to = _a.to, i = _a.input;
-                return to === node.id && i === input.id;
-            });
-            // In the case where a node has been deleted from the graph,
-            // dataInputs won't have been udpated until a recompile completes
-            var fromNode = edge && graph.nodes.find(function (_a) {
-                var id = _a.id;
-                return id === edge.from;
-            });
-            if (fromNode) {
-                // If this is a baked input, we need to set the engine property to force
-                // whatever we're baking to generate.
-                if (input.baked) {
-                    // Find the corresponding property on the node and get the default
-                    // setting
-                    var property = (node.config.properties || []).find(function (p) { return p.property === input.property; });
-                    if (property) {
-                        graphProperties[input.property] = defaultPropertySetting(property);
-                    }
-                    else {
-                        console.error('Property not found on input node', node, input);
-                        throw new Error('Property not found on input node');
-                    }
-                    // Other inputs should(?) be data if not baked
-                }
-                else {
-                    try {
-                        graphProperties[input.property] = (0, evaluate_1.evaluateNode)(engine, graph, fromNode);
-                    }
-                    catch (err) {
-                        console.error('Tried to evaluate a non-data node!', {
-                            err: err,
-                        });
-                    }
-                }
-            }
-        });
-    });
-    return graphProperties;
-};
-exports.collectInitialEvaluatedGraphProperties = collectInitialEvaluatedGraphProperties;

package/cjs/graph/base-node.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeInput = void 0;
-var nodeInput = function (displayName, id, type, dataType, accepts, bakeable, property) { return ({
-    displayName: displayName,
-    id: id,
-    type: type,
-    dataType: dataType,
-    accepts: accepts,
-    bakeable: bakeable,
-    property: property,
-}); };
-exports.nodeInput = nodeInput;

package/cjs/graph/code-nodes.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourceType = exports.property = exports.mapInputName = void 0;
-var mapInputName = function (node, _a) {
-    var _b, _c;
-    var id = _a.id, displayName = _a.displayName;
-    return ((_c = (_b = node.config) === null || _b === void 0 ? void 0 : _b.inputMapping) === null || _c === void 0 ? void 0 : _c[id]) || displayName;
-};
-exports.mapInputName = mapInputName;
-var property = function (displayName, property, type, fillerName, defaultValue) { return ({
-    displayName: displayName,
-    type: type,
-    property: property,
-    fillerName: fillerName,
-    defaultValue: defaultValue,
-}); };
-exports.property = property;
-var SourceType;
-(function (SourceType) {
-    SourceType["SHADER_PROGRAM"] = "Shader Program";
-    SourceType["EXPRESSION"] = "Expression";
-    SourceType["FN_BODY_FRAGMENT"] = "Function Body Fragment";
-})(SourceType = exports.SourceType || (exports.SourceType = {}));

package/cjs/graph/context.js

@@ -1,253 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeGraphContext = exports.computeAllContexts = exports.computeContextForNodes = exports.isError = void 0;
-var lodash_groupby_1 = __importDefault(require("lodash.groupby"));
-var code_nodes_1 = require("./code-nodes");
-var graph_types_1 = require("./graph-types");
-var graph_1 = require("./graph");
-var parsers_1 = require("./parsers");
-var makeError = function (nodeId) {
-    var errors = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        errors[_i - 1] = arguments[_i];
-    }
-    return ({
-        type: 'errors',
-        nodeId: nodeId,
-        errors: errors,
-    });
-};
-var isError = function (test) {
-    return (test === null || test === void 0 ? void 0 : test.type) === 'errors';
-};
-exports.isError = isError;
-// Merge existing node inputs, and inputs based on properties, with new ones
-// found from the source code, using the *id* as the uniqueness key. Any filler input gets
-// merged into property inputs with the same id. This preserves the
-// "baked" property on node inputs which is toggle-able in the graph
-var collapseNodeInputs = function (node, updatedInputs) {
-    return Object.values((0, lodash_groupby_1.default)(__spreadArray(__spreadArray([], __read(updatedInputs), false), __read(node.inputs), false), function (i) { return i.id; })).map(function (dupes) { return dupes.reduce(function (node, dupe) { return (__assign(__assign({}, node), dupe)); }); });
-};
-var computeNodeContext = function (engineContext, engine, graph, node) { return __awaiter(void 0, void 0, void 0, function () {
-    var parser, sibling, onBeforeCompile, manipulateAst, inputEdges, ast, dataInputs, computedInputs, nodeContext;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                parser = __assign(__assign({}, (parsers_1.coreParsers[node.type] || parsers_1.coreParsers[graph_types_1.NodeType.SOURCE])), (engine.parsers[node.type] || {}));
-                sibling = (0, graph_1.findLinkedNode)(graph, node.id);
-                onBeforeCompile = parser.onBeforeCompile, manipulateAst = parser.manipulateAst;
-                if (!onBeforeCompile) return [3 /*break*/, 2];
-                return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
-            case 1:
-                _a.sent();
-                _a.label = 2;
-            case 2:
-                inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
-                try {
-                    ast = parser.produceAst(engineContext, engine, graph, node, inputEdges);
-                    if (manipulateAst) {
-                        ast = manipulateAst(engineContext, engine, graph, ast, inputEdges, node, sibling);
-                    }
-                }
-                catch (error) {
-                    console.error('Error parsing source code!', { error: error, node: node });
-                    return [2 /*return*/, makeError(node.id, error)];
-                }
-                dataInputs = (0, lodash_groupby_1.default)((0, graph_1.filterGraphFromNode)(graph, node, {
-                    input: function (input, b, c, fromNode) {
-                        return input.bakeable && (fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'source';
-                    },
-                }, 1).inputs[node.id] || [], 'id');
-                computedInputs = parser.findInputs(engineContext, ast, inputEdges, node, sibling);
-                node.inputs = collapseNodeInputs(node, computedInputs.map(function (_a) {
-                    var _b = __read(_a, 1), i = _b[0];
-                    return (__assign(__assign({}, i), { displayName: (0, code_nodes_1.mapInputName)(node, i) }));
-                })).map(function (input) { return (__assign(__assign({}, input), (input.id in dataInputs ? { baked: true } : {}))); });
-                nodeContext = {
-                    ast: ast,
-                    id: node.id,
-                    inputFillers: computedInputs.reduce(function (acc, _a) {
-                        var _b;
-                        var _c = __read(_a, 3), input = _c[0], filler = _c[1], args = _c[2];
-                        return (__assign(__assign({}, acc), (_b = {}, _b[input.id] = {
-                            filler: filler,
-                            args: args,
-                        }, _b)));
-                    }, {}),
-                };
-                // Skip mangling if the node tells us to, which probably means it's an engine
-                // node where we don't care about renaming all the variables, or if it's
-                // an expression, where we want to be in the context of other variables
-                // TODO: Use global undefined engine variables here?
-                if (node.config.mangle !== false &&
-                    node.sourceType !== code_nodes_1.SourceType.EXPRESSION &&
-                    node.sourceType !== code_nodes_1.SourceType.FN_BODY_FRAGMENT) {
-                    (0, graph_1.mangleEntireProgram)(engine, ast, node, (0, graph_1.findLinkedNode)(graph, node.id));
-                }
-                return [2 /*return*/, nodeContext];
-        }
-    });
-}); };
-var computeContextForNodes = function (engineContext, engine, graph, nodes) { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        return [2 /*return*/, nodes
-                .filter(graph_1.isSourceNode)
-                .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
-                var context, nodeContextOrError;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, ctx];
-                        case 1:
-                            context = _a.sent();
-                            if ((0, exports.isError)(context)) {
-                                return [2 /*return*/, context];
-                            }
-                            return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
-                        case 2:
-                            nodeContextOrError = _a.sent();
-                            if ((0, exports.isError)(nodeContextOrError)) {
-                                return [2 /*return*/, nodeContextOrError];
-                            }
-                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
-                            return [2 /*return*/, context];
-                    }
-                });
-            }); }, Promise.resolve(engineContext.nodes))];
-    });
-}); };
-exports.computeContextForNodes = computeContextForNodes;
-/**
- * Compute the context for every node in the graph, done on initial graph load
- * to compute the inputs/outputs for every node
- */
-var computeAllContexts = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
-    var result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, graph.nodes)];
-            case 1:
-                result = _a.sent();
-                if ((0, exports.isError)(result)) {
-                    return [2 /*return*/, result];
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
-exports.computeAllContexts = computeAllContexts;
-/**
- * Compute the contexts for nodes starting from the outputs, working backwards.
- * Used to only (re)-compute context for any actively used nodes
- */
-var computeGraphContext = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
-    var outputFrag, outputVert, vertexIds, fragmentIds, unlinkedNodes, vertNodesOrError, fragNodesOrError;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
-                if (!outputFrag) {
-                    throw new Error('No fragment output in graph');
-                }
-                outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
-                if (!outputVert) {
-                    throw new Error('No vertex output in graph');
-                }
-                vertexIds = (0, graph_1.collectConnectedNodes)(graph, outputVert);
-                fragmentIds = (0, graph_1.collectConnectedNodes)(graph, outputFrag);
-                unlinkedNodes = (0, graph_1.findLinkedVertexNodes)(graph, vertexIds);
-                return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, __spreadArray(__spreadArray([
-                        outputVert
-                    ], __read(Object.values(vertexIds).filter(function (node) { return node.id !== outputVert.id; })), false), __read(unlinkedNodes), false))];
-            case 1:
-                vertNodesOrError = _a.sent();
-                if ((0, exports.isError)(vertNodesOrError)) {
-                    return [2 /*return*/, vertNodesOrError];
-                }
-                return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, __spreadArray([
-                        outputFrag
-                    ], __read(Object.values(fragmentIds).filter(function (node) { return node.id !== outputFrag.id; })), false))];
-            case 2:
-                fragNodesOrError = _a.sent();
-                if ((0, exports.isError)(fragNodesOrError)) {
-                    return [2 /*return*/, fragNodesOrError];
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
-exports.computeGraphContext = computeGraphContext;