@shaderfrog/core 1.1.0 → 1.1.2

package/{dist/graph → graph}/graph.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -70,18 +71,20 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
-import { computeGraphContext, isError, } from './context';
-import { emptyShaderSections, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
-import { makeExpression } from '../util/ast';
-import { ensure } from '../util/ensure';
-import { SourceType } from './code-nodes';
-import { nodeInput } from './base-node';
-import { makeId } from '../util/id';
-import { coreParsers } from './parsers';
-import { toGlsl } from './evaluate';
-import { EdgeLink, MAGIC_OUTPUT_STMTS, NodeType, } from './graph-types';
-import { generate } from '@shaderfrog/glsl-parser';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSource = exports.collectNodeProperties = exports.compileGraph = exports.compileNode = exports.isDataInput = exports.filterGraphNodes = exports.collectConnectedNodes = exports.filterGraphFromNode = exports.prepopulatePropertyInputs = exports.mergeSearchResults = exports.consSearchResult = exports.findLinkedVertexNodes = exports.findLinkedNode = exports.resetGraphIds = exports.ensureFromNode = exports.mangleMainFn = exports.mangleEntireProgram = exports.mangleVar = exports.mangleName = exports.nodeName = exports.doesLinkThruShader = exports.findNode = exports.isSourceNode = exports.isDataNode = void 0;
+var utils_1 = require("@shaderfrog/glsl-parser/parser/utils");
+var context_1 = require("./context");
+var shader_sections_1 = require("./shader-sections");
+var ast_1 = require("../util/ast");
+var ensure_1 = require("../util/ensure");
+var code_nodes_1 = require("./code-nodes");
+var base_node_1 = require("./base-node");
+var id_1 = require("../util/id");
+var parsers_1 = require("./parsers");
+var evaluate_1 = require("./evaluate");
+var graph_types_1 = require("./graph-types");
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
 var log = function () {
     var _a;
     var args = [];
@@ -90,37 +93,42 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.graph)\x1b[0m'], __read(args), false));
 };
-export var isDataNode = function (node) {
+var isDataNode = function (node) {
     return 'value' in node;
 };
-export var isSourceNode = function (node) {
-    return !isDataNode(node);
+exports.isDataNode = isDataNode;
+var isSourceNode = function (node) {
+    return !(0, exports.isDataNode)(node);
 };
-export var findNode = function (graph, id) {
-    return ensure(graph.nodes.find(function (node) { return node.id === id; }));
+exports.isSourceNode = isSourceNode;
+var findNode = function (graph, id) {
+    return (0, ensure_1.ensure)(graph.nodes.find(function (node) { return node.id === id; }));
 };
-export var doesLinkThruShader = function (graph, node) {
-    var edges = graph.edges.filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE && edge.from === node.id; });
+exports.findNode = findNode;
+var doesLinkThruShader = function (graph, node) {
+    var edges = graph.edges.filter(function (edge) { return edge.type !== graph_types_1.EdgeLink.NEXT_STAGE && edge.from === node.id; });
     if (edges.length === 0) {
         return false;
     }
     return edges.reduce(function (foundShader, edge) {
-        var upstreamNode = ensure(graph.nodes.find(function (node) { return node.id === edge.to; }));
+        var upstreamNode = (0, ensure_1.ensure)(graph.nodes.find(function (node) { return node.id === edge.to; }));
         return (foundShader ||
             // TODO: LARD this probably will introduce some insidius hard to track
             // down bug, as I try to pull toon and phong up out of core, I need to
             // know if a graph links through a "shader" which now means somehting
             // different... does a config object need isShader? Can we compute it from
             // inputs/ outputs/source?
-            (upstreamNode.sourceType !== SourceType.EXPRESSION &&
-                upstreamNode.type !== NodeType.OUTPUT) ||
-            doesLinkThruShader(graph, upstreamNode));
+            (upstreamNode.sourceType !== code_nodes_1.SourceType.EXPRESSION &&
+                upstreamNode.type !== graph_types_1.NodeType.OUTPUT) ||
+            (0, exports.doesLinkThruShader)(graph, upstreamNode));
     }, false);
 };
-export var nodeName = function (node) {
+exports.doesLinkThruShader = doesLinkThruShader;
+var nodeName = function (node) {
     return 'main_' + node.name.replace(/[^a-zA-Z0-9]/g, ' ').replace(/ +/g, '_');
 };
-export var mangleName = function (name, node, nextSibling) {
+exports.nodeName = nodeName;
+var mangleName = function (name, node, nextSibling) {
     // Mangle a name to its next stage node, so the vertex suffix becomes the
     // fragment id, but not the other way around.
     var id = (nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.stage) === 'fragment'
@@ -128,28 +136,33 @@ export var mangleName = function (name, node, nextSibling) {
         : node.id;
     return "".concat(name, "_").concat(id);
 };
-export var mangleVar = function (name, engine, node, sibling) { return (engine.preserve.has(name) ? name : mangleName(name, node, sibling)); };
-export var mangleEntireProgram = function (engine, ast, node, sibling) {
-    renameBindings(ast.scopes[0], function (name, n) {
-        return n.doNotDescope ? name : mangleVar(name, engine, node, sibling);
+exports.mangleName = mangleName;
+var mangleVar = function (name, engine, node, sibling) { return (engine.preserve.has(name) ? name : (0, exports.mangleName)(name, node, sibling)); };
+exports.mangleVar = mangleVar;
+var mangleEntireProgram = function (engine, ast, node, sibling) {
+    (0, utils_1.renameBindings)(ast.scopes[0], function (name, n) {
+        return n.doNotDescope ? name : (0, exports.mangleVar)(name, engine, node, sibling);
     });
-    mangleMainFn(ast, node, sibling);
+    (0, exports.mangleMainFn)(ast, node, sibling);
 };
-export var mangleMainFn = function (ast, node, sibling) {
-    renameFunctions(ast.scopes[0], function (name) {
-        return name === 'main' ? nodeName(node) : mangleName(name, node, sibling);
+exports.mangleEntireProgram = mangleEntireProgram;
+var mangleMainFn = function (ast, node, sibling) {
+    (0, utils_1.renameFunctions)(ast.scopes[0], function (name) {
+        return name === 'main' ? (0, exports.nodeName)(node) : (0, exports.mangleName)(name, node, sibling);
     });
 };
-export var ensureFromNode = function (graph, inputEdge) {
-    return ensure(graph.nodes.find(function (_a) {
+exports.mangleMainFn = mangleMainFn;
+var ensureFromNode = function (graph, inputEdge) {
+    return (0, ensure_1.ensure)(graph.nodes.find(function (_a) {
         var id = _a.id;
         return id === inputEdge.from;
     }), "Orphaned edge! There is an edge fro \"".concat(inputEdge.from, "\" to \"").concat(inputEdge.to, "\", but from node ").concat(inputEdge.from, " does not exist in the graph."));
 };
-export var resetGraphIds = function (graph) {
+exports.ensureFromNode = ensureFromNode;
+var resetGraphIds = function (graph) {
     var idMap = {};
     var map = function (id) {
-        idMap[id] = idMap[id] || makeId();
+        idMap[id] = idMap[id] || (0, id_1.makeId)();
         return idMap[id];
     };
     return {
@@ -157,26 +170,28 @@ export var resetGraphIds = function (graph) {
         edges: graph.edges.map(function (e) { return (__assign(__assign({}, e), { id: map(e.id), from: map(e.from), to: map(e.to) })); }),
     };
 };
-export var findLinkedNode = function (graph, id) {
-    var edgeLink = graph.edges.find(function (e) { return e.type === EdgeLink.NEXT_STAGE && (e.from === id || e.to === id); });
+exports.resetGraphIds = resetGraphIds;
+var findLinkedNode = function (graph, id) {
+    var edgeLink = graph.edges.find(function (e) { return e.type === graph_types_1.EdgeLink.NEXT_STAGE && (e.from === id || e.to === id); });
     var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === id ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
     return graph.nodes.find(function (node) { return node.id === otherId; });
 };
+exports.findLinkedNode = findLinkedNode;
 /**
  * Find any unconnected vertex nodes linked to collected fragment nodes
  */
-export var findLinkedVertexNodes = function (graph, existingIds) {
+var findLinkedVertexNodes = function (graph, existingIds) {
     if (existingIds === void 0) { existingIds = {}; }
     // Group edges by where they point
     var edgeLinks = graph.edges
-        .filter(function (e) { return e.type === EdgeLink.NEXT_STAGE; })
+        .filter(function (e) { return e.type === graph_types_1.EdgeLink.NEXT_STAGE; })
         .reduce(function (edges, edge) {
         var _a;
         return (__assign(__assign({}, edges), (_a = {}, _a[edge.to] = edge, _a[edge.from] = edge, _a)));
     }, {});
     return graph.nodes.filter(function (node) {
         // If this is a vertex node
-        return isSourceNode(node) &&
+        return (0, exports.isSourceNode)(node) &&
             node.stage === 'vertex' &&
             // That's linked
             node.id in edgeLinks &&
@@ -184,25 +199,29 @@ export var findLinkedVertexNodes = function (graph, existingIds) {
             !existingIds[node.id];
     });
 };
-export var consSearchResult = function () { return ({
+exports.findLinkedVertexNodes = findLinkedVertexNodes;
+var consSearchResult = function () { return ({
     nodes: {},
     inputs: {},
     edges: [],
 }); };
-export var mergeSearchResults = function (a, b) { return ({
+exports.consSearchResult = consSearchResult;
+var mergeSearchResults = function (a, b) { return ({
     nodes: __assign(__assign({}, a.nodes), b.nodes),
     inputs: __assign(__assign({}, a.inputs), b.inputs),
     edges: __spreadArray(__spreadArray([], __read(a.edges), false), __read(b.edges), false),
 }); };
+exports.mergeSearchResults = mergeSearchResults;
 /**
  * Create the inputs on a node from the properties. This used to be done at
  * context time. Doing it at node creation time lets us auto-bake edges into
  * the node at initial graph creation time.
  */
-export var prepopulatePropertyInputs = function (node) { return (__assign(__assign({}, node), { inputs: __spreadArray(__spreadArray([], __read(node.inputs), false), __read((node.config.properties || []).map(function (property) {
-        return nodeInput(property.displayName, "property_".concat(property.property), 'property', property.type, ['data'], !!property.fillerName, // bakeable
+var prepopulatePropertyInputs = function (node) { return (__assign(__assign({}, node), { inputs: __spreadArray(__spreadArray([], __read(node.inputs), false), __read((node.config.properties || []).map(function (property) {
+        return (0, base_node_1.nodeInput)(property.displayName, "property_".concat(property.property), 'property', property.type, ['data'], !!property.fillerName, // bakeable
         property.property);
     })), false) })); };
+exports.prepopulatePropertyInputs = prepopulatePropertyInputs;
 /**
  * Recursively filter the graph, starting from a specific node, looking for
  * nodes and edges that match predicates.
@@ -210,10 +229,10 @@ export var prepopulatePropertyInputs = function (node) { return (__assign(__assi
  * Inputs can only be filtered if the graph context has been computed, since
  * inputs aren't created until then.
  */
-export var filterGraphFromNode = function (graph, node, predicates, depth, lastResult) {
+var filterGraphFromNode = function (graph, node, predicates, depth, lastResult) {
     var _a;
     if (depth === void 0) { depth = Infinity; }
-    if (lastResult === void 0) { lastResult = consSearchResult(); }
+    if (lastResult === void 0) { lastResult = (0, exports.consSearchResult)(); }
     var inputs = node.inputs;
     var inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
     var nodeAcc = __assign({}, (predicates.node && predicates.node(node, inputEdges, lastResult)
@@ -222,7 +241,7 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
     return inputEdges.reduce(function (acc, inputEdge) {
         var _a;
         var input = inputs.find(function (i) { return i.id === inputEdge.input; });
-        var fromNode = inputEdge ? ensureFromNode(graph, inputEdge) : undefined;
+        var fromNode = inputEdge ? (0, exports.ensureFromNode)(graph, inputEdge) : undefined;
         var inputAcc = __assign(__assign({}, acc.inputs), (input &&
             predicates.input &&
             predicates.input(input, node, inputEdge, fromNode, lastResult)
@@ -235,47 +254,51 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
         // the next node, it has the latest accumulator
         var intermediateAcc = __assign(__assign({}, acc), { inputs: inputAcc, edges: edgeAcc });
         if (inputEdge && fromNode && depth > 1) {
-            var result = filterGraphFromNode(graph, fromNode, predicates, depth - 1, intermediateAcc);
-            return mergeSearchResults(intermediateAcc, result);
+            var result = (0, exports.filterGraphFromNode)(graph, fromNode, predicates, depth - 1, intermediateAcc);
+            return (0, exports.mergeSearchResults)(intermediateAcc, result);
         }
         else {
             return intermediateAcc;
         }
     }, accumulatedResult);
 };
-export var collectConnectedNodes = function (graph, node) {
-    return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
+exports.filterGraphFromNode = filterGraphFromNode;
+var collectConnectedNodes = function (graph, node) {
+    return (0, exports.filterGraphFromNode)(graph, node, { node: function () { return true; } }).nodes;
 };
-export var filterGraphNodes = function (graph, nodes, filter, depth) {
+exports.collectConnectedNodes = collectConnectedNodes;
+var filterGraphNodes = function (graph, nodes, filter, depth) {
     if (depth === void 0) { depth = Infinity; }
     return nodes.reduce(function (acc, node) {
-        var result = filterGraphFromNode(graph, node, filter, depth);
+        var result = (0, exports.filterGraphFromNode)(graph, node, filter, depth);
         return {
             nodes: __assign(__assign({}, acc.nodes), result.nodes),
             inputs: __assign(__assign({}, acc.inputs), result.inputs),
             edges: __assign(__assign({}, acc.edges), result.edges),
         };
-    }, consSearchResult());
+    }, (0, exports.consSearchResult)());
 };
+exports.filterGraphNodes = filterGraphNodes;
 // before data inputs were known by the input.category being node or data. I
 // tried updating inputs to have acepts: [code|data] and "baked" now is there a
 // way to know if we're plugging in code or data?
-export var isDataInput = function (input) {
+var isDataInput = function (input) {
     return (input.type === 'uniform' || input.type === 'property') && !input.baked;
 };
-export var compileNode = function (engine, graph, edges, engineContext, node, activeIds) {
+exports.isDataInput = isDataInput;
+var compileNode = function (engine, graph, edges, engineContext, node, activeIds) {
     var _a, _b;
     if (activeIds === void 0) { activeIds = {}; }
     // THIS DUPLICATES OTHER LINE
-    var parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+    var parser = __assign(__assign({}, (parsers_1.coreParsers[node.type] || parsers_1.coreParsers[graph_types_1.NodeType.SOURCE])), (engine.parsers[node.type] || {}));
     var inputs = node.inputs;
     if (!parser) {
         console.error(node);
         throw new Error("No parser found for ".concat(node.name, " (").concat(node.type, ", id ").concat(node.id, ")"));
     }
-    var nodeContext = isDataNode(node)
+    var nodeContext = (0, exports.isDataNode)(node)
         ? null
-        : ensure(engineContext.nodes[node.id], "No node context found for \"".concat(node.name, "\" (id ").concat(node.id, ")!"));
+        : (0, ensure_1.ensure)(engineContext.nodes[node.id], "No node context found for \"".concat(node.name, "\" (id ").concat(node.id, ")!"));
     var _c = (nodeContext || {}), ast = _c.ast, inputFillers = _c.inputFillers;
     if (!inputs) {
         throw new Error("I'm drunk and I think this case should be impossible");
@@ -283,13 +306,13 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
     var compiledIds = activeIds;
     var inputEdges = edges.filter(function (edge) { return edge.to === node.id; });
     if (inputEdges.length) {
-        var continuation_1 = emptyShaderSections();
+        var continuation_1 = (0, shader_sections_1.emptyShaderSections)();
         inputEdges
-            .filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE; })
+            .filter(function (edge) { return edge.type !== graph_types_1.EdgeLink.NEXT_STAGE; })
             .map(function (edge) { return ({
             edge: edge,
-            fromNode: ensure(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
-            input: ensure(inputs.find(function (_a) {
+            fromNode: (0, ensure_1.ensure)(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
+            input: (0, ensure_1.ensure)(inputs.find(function (_a) {
                 var id = _a.id;
                 return id == edge.input;
             }), "GraphNode \"".concat(node.name, "\"").concat(node.stage ? " (".concat(node.stage, ")") : '', " has no input ").concat(edge.input, "!\nAvailable:").concat(inputs
@@ -301,22 +324,22 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
         }); })
             .filter(function (_a) {
             var input = _a.input;
-            return !isDataInput(input);
+            return !(0, exports.isDataInput)(input);
         })
             .forEach(function (_a) {
             var _b;
             var fromNode = _a.fromNode, edge = _a.edge, input = _a.input;
-            var _c = __read(compileNode(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _c[0], fillerAst = _c[1], childIds = _c[2];
+            var _c = __read((0, exports.compileNode)(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _c[0], fillerAst = _c[1], childIds = _c[2];
             if (!fillerAst) {
                 throw new TypeError("Expected a filler ast from node ID ".concat(fromNode.id, " (").concat(fromNode.type, ") but none was returned"));
             }
-            continuation_1 = mergeShaderSections(continuation_1, inputSections);
+            continuation_1 = (0, shader_sections_1.mergeShaderSections)(continuation_1, inputSections);
             compiledIds = __assign(__assign({}, compiledIds), childIds);
             var filler;
             var fillerName;
             if (nodeContext) {
                 if (input.property) {
-                    fillerName = ensure((_b = (node.config.properties || []).find(function (p) { return p.property === input.property; })) === null || _b === void 0 ? void 0 : _b.fillerName, "Node \"".concat(node.name, "\" has no property named \"").concat(input.property, "\" to find the filler for"));
+                    fillerName = (0, ensure_1.ensure)((_b = (node.config.properties || []).find(function (p) { return p.property === input.property; })) === null || _b === void 0 ? void 0 : _b.fillerName, "Node \"".concat(node.name, "\" has no property named \"").concat(input.property, "\" to find the filler for"));
                     filler = inputFillers[fillerName];
                 }
                 else {
@@ -365,7 +388,7 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
                         ];
                         // @ts-ignore
                         var scope = fc.ast.scopes[0];
-                        renameBindings(scope, function (name, node) {
+                        (0, utils_1.renameBindings)(scope, function (name, node) {
                             return node.type !== 'declaration' && name === 'vUv'
                                 ? 'vv'
                                 : name;
@@ -381,13 +404,13 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
         });
         // Order matters here! *Prepend* the input nodes to this one, because
         // you have to declare functions in order of use in GLSL
-        var sections = mergeShaderSections(continuation_1, isDataNode(node) ||
-            node.sourceType === SourceType.EXPRESSION ||
-            node.sourceType === SourceType.FN_BODY_FRAGMENT
-            ? emptyShaderSections()
-            : findShaderSections(ast));
-        var filler = isDataNode(node)
-            ? makeExpression(toGlsl(node))
+        var sections = (0, shader_sections_1.mergeShaderSections)(continuation_1, (0, exports.isDataNode)(node) ||
+            node.sourceType === code_nodes_1.SourceType.EXPRESSION ||
+            node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
+            ? (0, shader_sections_1.emptyShaderSections)()
+            : (0, shader_sections_1.findShaderSections)(ast));
+        var filler = (0, exports.isDataNode)(node)
+            ? (0, ast_1.makeExpression)((0, evaluate_1.toGlsl)(node))
             : parser.produceFiller(node, ast);
         return [sections, filler, __assign(__assign({}, compiledIds), (_a = {}, _a[node.id] = node, _a))];
     }
@@ -395,44 +418,45 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
         // TODO: This duplicates the above branch, and also does this mean we
         // recalculate the shader sections and filler for every edge? Can I move
         // these lines above the loop?
-        var sections = isDataNode(node) ||
-            node.sourceType === SourceType.EXPRESSION ||
-            node.sourceType === SourceType.FN_BODY_FRAGMENT
-            ? emptyShaderSections()
-            : findShaderSections(ast);
-        var filler = isDataNode(node)
-            ? makeExpression(toGlsl(node))
+        var sections = (0, exports.isDataNode)(node) ||
+            node.sourceType === code_nodes_1.SourceType.EXPRESSION ||
+            node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
+            ? (0, shader_sections_1.emptyShaderSections)()
+            : (0, shader_sections_1.findShaderSections)(ast);
+        var filler = (0, exports.isDataNode)(node)
+            ? (0, ast_1.makeExpression)((0, evaluate_1.toGlsl)(node))
             : parser.produceFiller(node, ast);
         return [sections, filler, __assign(__assign({}, compiledIds), (_b = {}, _b[node.id] = node, _b))];
     }
 };
-export var compileGraph = function (engineContext, engine, graph) {
+exports.compileNode = compileNode;
+var compileGraph = function (engineContext, engine, graph) {
     // computeGraphContext(engineContext, engine, graph);
     var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
     if (!outputFrag) {
         throw new Error('No fragment output in graph');
     }
-    var _a = __read(compileNode(engine, graph, graph.edges, engineContext, outputFrag), 3), fragment = _a[0], fragmentIds = _a[2];
+    var _a = __read((0, exports.compileNode)(engine, graph, graph.edges, engineContext, outputFrag), 3), fragment = _a[0], fragmentIds = _a[2];
     var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
     if (!outputVert) {
         throw new Error('No vertex output in graph');
     }
-    var vertexIds = collectConnectedNodes(graph, outputVert);
+    var vertexIds = (0, exports.collectConnectedNodes)(graph, outputVert);
     // Some fragment shaders reference vertex shaders which may not have been
     // given edges in the graph. Build invisible edges from these vertex nodes to
     // the hidden "mainStmts" input on the output node, which inlines the function
     // calls to those vertex main() statements and includes them in the output
-    var orphanNodes = findLinkedVertexNodes(graph, vertexIds);
+    var orphanNodes = (0, exports.findLinkedVertexNodes)(graph, vertexIds);
     var orphanEdges = orphanNodes.map(function (node) { return ({
-        id: makeId(),
+        id: (0, id_1.makeId)(),
         from: node.id,
         to: outputVert.id,
         output: 'main',
-        input: "filler_".concat(MAGIC_OUTPUT_STMTS),
+        input: "filler_".concat(graph_types_1.MAGIC_OUTPUT_STMTS),
         stage: 'vertex',
         category: 'code',
     }); });
-    var _b = __read(compileNode(engine, graph, __spreadArray(__spreadArray([], __read(graph.edges), false), __read(orphanEdges), false), engineContext, outputVert), 2), vertex = _b[0];
+    var _b = __read((0, exports.compileNode)(engine, graph, __spreadArray(__spreadArray([], __read(graph.edges), false), __read(orphanEdges), false), engineContext, outputVert), 2), vertex = _b[0];
     // Every compileNode returns the AST so far, as well as the filler for the
     // next node with inputs. On the final step, we discard the filler
     return {
@@ -444,6 +468,7 @@ export var compileGraph = function (engineContext, engine, graph) {
         activeNodeIds: new Set(__spreadArray(__spreadArray(__spreadArray([], __read(Object.keys(vertexIds)), false), __read(Object.keys(fragmentIds)), false), __read(orphanNodes.map(function (node) { return node.id; })), false)),
     };
 };
+exports.compileGraph = compileGraph;
 /**
  * Find engine nodes to set properties on, like find a Physical node so
  * consumers can set physicalNode.myProperty = 123.
@@ -451,7 +476,7 @@ export var compileGraph = function (engineContext, engine, graph) {
  * Finds all active nodes in the graph that have inputs that are properties,
  * which currently means it will find all active engine nodes.
  */
-export var collectNodeProperties = function (graph) {
+var collectNodeProperties = function (graph) {
     var nodesWithProperties = {
         node: function (node) {
             var _a;
@@ -463,35 +488,36 @@ export var collectNodeProperties = function (graph) {
     };
     var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
     var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
-    var fragProperties = filterGraphFromNode(graph, outputFrag, nodesWithProperties);
-    var vertProperties = filterGraphFromNode(graph, outputVert, nodesWithProperties);
+    var fragProperties = (0, exports.filterGraphFromNode)(graph, outputFrag, nodesWithProperties);
+    var vertProperties = (0, exports.filterGraphFromNode)(graph, outputVert, nodesWithProperties);
     return {
         nodes: __assign(__assign({}, fragProperties.nodes), vertProperties.nodes),
         inputs: __assign(__assign({}, fragProperties.inputs), vertProperties.inputs),
         edges: __assign(__assign({}, fragProperties.edges), vertProperties.edges),
     };
 };
-export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
+exports.collectNodeProperties = collectNodeProperties;
+var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
     var result, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
+            case 0: return [4 /*yield*/, (0, context_1.computeGraphContext)(ctx, engine, graph)];
             case 1:
                 result = _a.sent();
-                if (isError(result)) {
+                if ((0, context_1.isError)(result)) {
                     return [2 /*return*/, result];
                 }
-                compileResult = compileGraph(ctx, engine, graph);
-                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions).program);
-                vertexResult = generate(shaderSectionsToProgram(compileResult.vertex, engine.mergeOptions).program);
-                dataInputs = filterGraphNodes(graph, [compileResult.outputFrag, compileResult.outputVert], { input: isDataInput }).inputs;
+                compileResult = (0, exports.compileGraph)(ctx, engine, graph);
+                fragmentResult = (0, glsl_parser_1.generate)((0, shader_sections_1.shaderSectionsToProgram)(compileResult.fragment, engine.mergeOptions).program);
+                vertexResult = (0, glsl_parser_1.generate)((0, shader_sections_1.shaderSectionsToProgram)(compileResult.vertex, engine.mergeOptions).program);
+                dataInputs = (0, exports.filterGraphNodes)(graph, [compileResult.outputFrag, compileResult.outputVert], { input: exports.isDataInput }).inputs;
                 dataNodes = Object.entries(dataInputs).reduce(function (acc, _a) {
                     var _b = __read(_a, 2), nodeId = _b[0], inputs = _b[1];
                     return inputs.reduce(function (iAcc, input) {
                         var fromEdge = graph.edges.find(function (edge) { return edge.to === nodeId && edge.input === input.id; });
                         var fromNode = fromEdge && graph.nodes.find(function (node) { return node.id === fromEdge.from; });
                         return fromNode
-                            ? __assign(__assign({}, iAcc), collectConnectedNodes(graph, fromNode)) : iAcc;
+                            ? __assign(__assign({}, iAcc), (0, exports.collectConnectedNodes)(graph, fromNode)) : iAcc;
                     }, acc);
                 }, {});
                 return [2 /*return*/, {
@@ -504,3 +530,4 @@ export var compileSource = function (graph, engine, ctx) { return __awaiter(void
         }
     });
 }); };
+exports.compileSource = compileSource;

package/{dist/graph → graph}/graph.test.js

@@ -1,25 +1,30 @@
-import util from 'util';
-import { parser } from '@shaderfrog/glsl-parser';
-import { generate } from '@shaderfrog/glsl-parser';
-import { addNode } from './graph-node';
-import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
-import { numberNode } from './data-nodes';
-import { makeEdge } from './edge';
-import { evaluateNode } from './evaluate';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = __importDefault(require("util"));
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var glsl_parser_2 = require("@shaderfrog/glsl-parser");
+var graph_node_1 = require("./graph-node");
+var shader_sections_1 = require("./shader-sections");
+var data_nodes_1 = require("./data-nodes");
+var edge_1 = require("./edge");
+var evaluate_1 = require("./evaluate");
 var inspect = function (thing) {
-    return console.log(util.inspect(thing, false, null, true));
+    return console.log(util_1.default.inspect(thing, false, null, true));
 };
 var mergeBlocks = function (ast1, ast2) {
-    var s1 = findShaderSections(ast1);
-    var s2 = findShaderSections(ast2);
-    var merged = mergeShaderSections(s1, s2);
-    return generate(shaderSectionsToProgram(merged, {
+    var s1 = (0, shader_sections_1.findShaderSections)(ast1);
+    var s2 = (0, shader_sections_1.findShaderSections)(ast2);
+    var merged = (0, shader_sections_1.mergeShaderSections)(s1, s2);
+    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)(merged, {
         includePrecisions: true,
         includeVersion: true,
     }));
 };
 var dedupe = function (code) {
-    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)((0, shader_sections_1.findShaderSections)(glsl_parser_1.parser.parse(code)), {
         includePrecisions: true,
         includeVersion: true,
     }));
@@ -121,47 +126,47 @@ var engine = {
 // });
 describe('evaluateNode()', function () {
     it('evaluates binary nodes', function () {
-        var finalAdd = addNode(id(), p);
-        var add2 = addNode(id(), p);
-        var num1 = numberNode(id(), 'number', p, '3');
-        var num2 = numberNode(id(), 'number', p, '5');
-        var num3 = numberNode(id(), 'number', p, '7');
+        var finalAdd = (0, graph_node_1.addNode)(id(), p);
+        var add2 = (0, graph_node_1.addNode)(id(), p);
+        var num1 = (0, data_nodes_1.numberNode)(id(), 'number', p, '3');
+        var num2 = (0, data_nodes_1.numberNode)(id(), 'number', p, '5');
+        var num3 = (0, data_nodes_1.numberNode)(id(), 'number', p, '7');
         var graph = {
             nodes: [num1, num2, num3, finalAdd, add2],
             edges: [
-                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
-                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
-                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
-                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+                (0, edge_1.makeEdge)(id(), num1.id, finalAdd.id, 'out', 'a'),
+                (0, edge_1.makeEdge)(id(), add2.id, finalAdd.id, 'out', 'b'),
+                (0, edge_1.makeEdge)(id(), num2.id, add2.id, 'out', 'a'),
+                (0, edge_1.makeEdge)(id(), num3.id, add2.id, 'out', 'b'),
             ],
         };
-        expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
+        expect((0, evaluate_1.evaluateNode)(engine, graph, finalAdd)).toBe(15);
     });
 });
 it('should merge uniforms with interface blocks', function () {
-    var astX = parser.parse("uniform vec2 x;");
-    var astY = parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
+    var astX = glsl_parser_1.parser.parse("uniform vec2 x;");
+    var astY = glsl_parser_1.parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
     expect(mergeBlocks(astX, astY)).toEqual("uniform vec2 x, y, z;\nuniform vec3 a;\n");
-    var astL01 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
-    var astL02 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL01 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
     expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astL001 = parser.parse("uniform Light0 { vec4 y; } x;", {
+    var astL001 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", {
         quiet: true,
     });
-    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astL002 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
     expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astLo01 = parser.parse("uniform Light0 x;", { quiet: true });
-    var astLo02 = parser.parse("uniform Light0 { vec4 y; } x;", {
+    var astLo01 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", {
         quiet: true,
     });
     expect(mergeBlocks(astLo01, astLo02)).toEqual("uniform Light0 { vec4 y; } x;\n");
     // This may be a bug, look at how the uniforms are merged. I at least want to
     // note its current behavior in this test
-    var vec2Arr1 = parser.parse("uniform vec2 y[5];");
-    var vec2Arr2 = parser.parse("uniform vec2 y[10];");
+    var vec2Arr1 = glsl_parser_1.parser.parse("uniform vec2 y[5];");
+    var vec2Arr2 = glsl_parser_1.parser.parse("uniform vec2 y[10];");
     expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
-    var block1 = parser.parse("uniform Scene { mat4 view; };");
-    var block2 = parser.parse("uniform Scene { mat4 view; };");
+    var block1 = glsl_parser_1.parser.parse("uniform Scene { mat4 view; };");
+    var block2 = glsl_parser_1.parser.parse("uniform Scene { mat4 view; };");
     expect(mergeBlocks(block1, block2)).toEqual("uniform Scene { mat4 view; };\n");
     // Verify these lines are preserved (they go through dedupeUniforms)
     expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");