@shaderfrog/core 2.0.0-beta.3 → 2.0.1

package/util/ast.js

@@ -1,3 +1,6 @@
+/**
+ * Utility functions to work with ASTs
+ */
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -37,7 +40,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { parser, generate } from '@shaderfrog/glsl-parser';
 import { visit, } from '@shaderfrog/glsl-parser/ast';
 import { addFnStmtWithIndent } from './whitespace';
-import { renameBinding, } from '@shaderfrog/glsl-parser/parser/utils';
+import { renameBinding } from '@shaderfrog/glsl-parser/parser/utils';
 var log = function () {
     var _a;
     var args = [];
@@ -159,11 +162,12 @@ export var from2To3 = function (ast, stage) {
         },
     });
 };
-export var makeStatement = function (stmt) {
+export var makeStatement = function (stmt, ws) {
+    if (ws === void 0) { ws = ''; }
     // log(`Parsing "${stmt}"`);
     var ast;
     try {
-        ast = parser.parse("".concat(stmt, ";\n"), { quiet: true });
+        ast = parser.parse("".concat(stmt, ";").concat(ws, "\n"), { quiet: true });
     }
     catch (error) {
         console.error({ stmt: stmt, error: error });
@@ -366,11 +370,28 @@ export var convert300MainToReturn = function (ast) {
     main.body.statements = addFnStmtWithIndent(main, rtn);
     ast.scopes[0].bindings[replacedReturn].references.push(rtn.expression);
 };
-export var generateFiller = function (filler) {
-    if (!filler) {
+export var generateFiller = function (ast) {
+    if (!ast) {
         throw new Error('Cannot generate void filler!');
     }
-    return Array.isArray(filler)
-        ? filler.map(generate).join('')
-        : generate(filler);
+    return Array.isArray(ast) ? ast.map(generate).join('') : generate(ast);
+};
+export var isDeclarationStatement = function (node) {
+    return node.type === 'declaration_statement' &&
+        node.declaration.type === 'declarator_list';
+};
+export var backfillAst = function (ast, fromType, targetVariable, mainFn) {
+    if (!ast.scopes[0].bindings[targetVariable]) {
+        console.warn("Variable \"".concat(targetVariable, "\" not found in global program scope to backfill! Variables: ").concat(Object.keys(ast.scopes[0].bindings)));
+    }
+    // Inject the backfill param as the arg
+    if (mainFn) {
+        mainFn.prototype.parameters = (mainFn.prototype.parameters || [])
+            .filter(
+        // Watch out for the main(void){} case!
+        function (arg) { return arg.specifier.specifier.token !== 'void'; })
+            .concat(parser.parse("void x(".concat(fromType, " ").concat(targetVariable, ") {}"))
+            .program[0].prototype.parameters);
+    }
+    return ast;
 };

package/util/ast.test.d.ts

@@ -0,0 +1 @@
+export {};

package/util/ast.test.js

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest';
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { backfillAst, findMain } from '../util/ast';
+it('backfillAst', function () {
+    var source = parser.parse("\nattribute vec2 vUv, xx;\nvoid main() {\n    gl_FragColor = vec4(vUv, xx);\n}");
+    var result = backfillAst(source, 'vec2', 'vUv', findMain(source));
+    expect(generate(result)).toBe("\nattribute vec2 vUv, xx;\nvoid main(vec2 vUv) {\n    gl_FragColor = vec4(vUv, xx);\n}");
+});
+it('backfillAst with void main fn', function () {
+    var source = parser.parse("\nattribute vec2 vUv;\nvoid main(void) {\n    gl_FragColor = vec4(vUv, 1.0, 1.0);\n}");
+    var result = backfillAst(source, 'vec2', 'vUv', findMain(source));
+    expect(generate(result)).toBe("\nattribute vec2 vUv;\nvoid main(vec2 vUv) {\n    gl_FragColor = vec4(vUv, 1.0, 1.0);\n}");
+});

package/util/whitespace.d.ts

@@ -16,3 +16,5 @@ export declare const getLiteralIndent: (node: {
 export declare const tryAddTrailingWhitespace: <T extends AstNode>(node: T, ws: string) => T;
 export declare const guessFnIndent: (fnBody: FunctionNode) => string;
 export declare const addFnStmtWithIndent: (fnBody: FunctionNode, newNode: string | AstNode) => AstNode[];
+export declare const unshiftFnStmtWithIndent: (fnBody: FunctionNode, newNode: string | AstNode) => AstNode[];
+export declare const spliceFnStmtWithIndent: (fnBody: FunctionNode, index: number, ...newNodes: (string | AstNode)[]) => AstNode[];

package/util/whitespace.js

@@ -79,6 +79,9 @@ export var guessFnIndent = function (fnBody) {
             return ws || getLiteralIndent(n.semi) || '';
         }, '');
 };
+var addWs = function (node, ws) {
+    return tryAddTrailingWhitespace(typeof node === 'string' ? makeFnStatement(node)[0] : node, ws);
+};
 export var addFnStmtWithIndent = function (fnBody, newNode) {
     var statements = fnBody.body.statements;
     var indent = guessFnIndent(fnBody);
@@ -86,6 +89,29 @@ export var addFnStmtWithIndent = function (fnBody, newNode) {
         // This simple hack is way easier than trying to modify the function body
         // opening brace and/or the previous statement
         { type: 'literal', literal: '', whitespace: indent },
-        tryAddTrailingWhitespace(typeof newNode === 'string' ? makeFnStatement(newNode)[0] : newNode, "\n"),
+        addWs(newNode, "\n"),
     ], false);
 };
+export var unshiftFnStmtWithIndent = function (fnBody, newNode) {
+    var statements = fnBody.body.statements;
+    var indent = guessFnIndent(fnBody);
+    return __spreadArray([
+        addWs(newNode, "\n"),
+        { type: 'literal', literal: '', whitespace: indent }
+    ], __read(statements), false);
+};
+export var spliceFnStmtWithIndent = function (fnBody, index) {
+    var newNodes = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        newNodes[_i - 2] = arguments[_i];
+    }
+    var statements = fnBody.body.statements;
+    var indent = guessFnIndent(fnBody);
+    return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(statements.slice(0, index)), false), __read(newNodes.map(function (n) { return addWs(n, "\n"); })), false), [
+        {
+            type: 'literal',
+            literal: '',
+            whitespace: indent,
+        }
+    ], false), __read(statements.slice(index)), false);
+};