glslify: error checking, refactor

Author: docd27

README.md

@@ -123,7 +123,7 @@ Available in [CHANGES.md](CHANGES.md).
 ## License
 
 Released under the [MIT license](LICENSE).\
-*Thanks to Vincent Wochnik ([rollup-plugin-glsl](https://github.com/vwochnik/rollup-plugin-glsl)) for the whitespace minification code.*
+*Strip whitespace function adapted from code by Vincent Wochnik ([rollup-plugin-glsl](https://github.com/vwochnik/rollup-plugin-glsl)).*
 
 Khronos tool binaries (built by the upstream projects) are distributed and installed with this plugin under the terms of the Apache License Version 2.0. See the corresponding LICENSE files in the ``bin`` folder.
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "rollup-plugin-glsl-optimize",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Import GLSL source files as strings. Pre-processed, validated and optimized with Khronos Group SPIRV-Tools. Supports glslify.",
   "homepage": "https://github.com/docd27/rollup-plugin-glsl-optimize#readme",
   "keywords": [
@@ -81,4 +81,4 @@
     "rollup-plugin-dts": "^3.0.1",
     "typescript": "^4.2.3"
   }
-}
+}

package.json

@@ -29,14 +29,14 @@ function earlyDel(targets = [], deleteOptions = {}) {
   };
 }
 
-function appendDts (filePath) {
+function appendDts(filePath) {
   const fileContent = fsSync.readFileSync(filePath, {encoding: 'utf8'});
   return {
     name: 'append-dts',
-    renderChunk (code) {
+    renderChunk(code) {
       return `${code}\n${fileContent}`;
-    }
-  }
+    },
+  };
 }
 
 export default [{
@@ -51,5 +51,5 @@ export default [{
     // appendDts('src/resources.d.ts'),
     del({hook: 'buildEnd', targets: [IN_DIR]}),
   ],
-  external: [ 'child_process' ],
+  external: ['child_process'],
 }];

rollup.config.bundletypes.mjs

@@ -1,6 +1,6 @@
 import {createFilter} from '@rollup/pluginutils';
 import {glslProcessSource} from './lib/glslProcess.js';
-import {dirname} from 'path';
+import {glslifyInit, glslifyProcessSource} from './lib/glslify.js';
 import * as fsSync from 'fs';
 
 /**
@@ -44,14 +44,9 @@ function generateCode(source) {
  *   File extensions within rollup to exclude.
  * @property {boolean} glslify
  *   Process sources using glslify prior to all preprocessing, validation and optimization.
- * @property {Partial<GlslifyOptions>} glslifyOptions
+ * @property {Partial<import('./lib/glslify.js').GlslifyOptions>} glslifyOptions
  *   When glslify enabled, pass these additional options to glslify.compile()
- * @typedef {GLSLPluginGlobalOptions & Partial<import('./lib/glslProcess').GLSLToolOptions>} GLSLPluginOptions
- */
-/**
- * @typedef {Object} GlslifyBaseOptions
- * @property {string} basedir
- * @typedef {{[key: string]: any} & GlslifyBaseOptions} GlslifyOptions
+ * @typedef {GLSLPluginGlobalOptions & Partial<import('./lib/glslProcess.js').GLSLToolOptions>} GLSLPluginOptions
  */
 /**
  * @param {Partial<GLSLPluginOptions>} userOptions
@@ -69,35 +64,23 @@ export default function glslOptimize(userOptions = {}) {
 
   const filter = createFilter(pluginOptions.include, pluginOptions.exclude);
 
-  /** @type {{(src:string, opts:GlslifyOptions):string}} */
-  let glslifyCompile;
-
   return {
     name: 'glsl-optimize',
 
     async options(options) {
       if (pluginOptions.glslify) { // Try to dynamically load glslify if installed
-        try {
-          // @ts-ignore
-          const glslify = await import('glslify');
-          if (glslify && glslify.compile && typeof glslify.compile === 'function') {
-            glslifyCompile = glslify.compile;
-          }
-        } catch {
-          // do nothing
-        }
+        await glslifyInit();
       }
       return options;
     },
 
+    /*
+      We use a load hook instead of transform because we want sourcemaps
+      to reflect the optimized shader source.
+    */
     async load(id) {
-      if (!id || !filter(id)) return;
+      if (!id || !filter(id) || !fsSync.existsSync(id)) return;
 
-      /*
-        We use a load hook instead of transform because we want sourcemaps
-        to reflect the optimized shader source.
-      */
-      if (!fsSync.existsSync(id)) return;
       let source;
       try {
         source = fsSync.readFileSync(id, {encoding: 'utf8'});
@@ -113,16 +96,9 @@ export default function glslOptimize(userOptions = {}) {
       }
 
       if (pluginOptions.glslify) {
-        if (!glslifyCompile) {
-          this.error({message: `glslify could not be found. Install it with npm i -D glslify`});
-        }
-        /** @type {GlslifyOptions} */
-        const glslifyOptions = {
-          basedir: dirname(id),
-          ...pluginOptions.glslifyOptions,
-        };
         try {
-          source = glslifyCompile(source, glslifyOptions);
+          source = await glslifyProcessSource(id, source, pluginOptions.glslifyOptions,
+              (message) => this.error({message}));
         } catch (err) {
           this.error({message: `Error processing GLSL source with glslify:\n${err.message}`});
         }

src/index.js

@@ -141,10 +141,10 @@ function getBuildDir(id) {
  * @param {string} source Source code
  * @param {GLSLStageName} stageName
  * @param {Partial<GLSLToolOptions>} [glslOptions]
- * @param {(message: string) => void} [errorLog]
+ * @param {(message: string) => void} [warnLog]
  * @return {Promise<import('rollup').SourceDescription>}
  */
-export async function glslProcessSource(id, source, stageName, glslOptions = {}, errorLog = console.error) {
+export async function glslProcessSource(id, source, stageName, glslOptions = {}, warnLog = console.error) {
 
   /** @type {GLSLToolOptions} */
   const options = {
@@ -180,7 +180,7 @@ export async function glslProcessSource(id, source, stageName, glslOptions = {},
   let outputFile = targetID;
 
   if (!fsSync.existsSync(targetDir)) {
-    errorLog(`Error resolving path: '${id}' : Khronos glslangValidator may fail to find includes`);
+    warnLog(`Error resolving path: '${id}' : Khronos glslangValidator may fail to find includes`);
     targetDir = process.cwd();
     targetID = id;
     outputFile = `temp`;

src/lib/glslProcess.js

@@ -0,0 +1,49 @@
+import * as path from 'path';
+import * as fsSync from 'fs';
+
+/**
+ * @typedef {Object} GlslifyBaseOptions
+ * @property {string} basedir
+ * @typedef {{[key: string]: any} & GlslifyBaseOptions} GlslifyOptions
+ */
+
+/** @type {{(src:string, opts:GlslifyOptions):string}} glslify.compile */
+let glslifyCompile;
+
+/**
+ * Try to dynamically load glslify if installed
+ */
+export async function glslifyInit() {
+  if (glslifyCompile) return;
+  try {
+    // @ts-ignore
+    const glslify = await import('glslify');
+    if (glslify && glslify.compile && typeof glslify.compile === 'function') {
+      glslifyCompile = glslify.compile;
+    }
+  } catch {
+    // do nothing
+  }
+}
+
+/**
+ * Process source with glslify
+ * @param {string} id File path
+ * @param {string} source Source code
+ * @param {Partial<GlslifyOptions>} options
+ * @param {(message: string) => never} failError
+ * @param {(message: string) => void} [warnLog]
+ */
+export async function glslifyProcessSource(id, source, options, failError, warnLog = console.error) {
+  if (!glslifyCompile) {
+    failError(`glslify could not be found. Install it with npm i -D glslify`);
+  }
+
+  let basedir = path.dirname(id);
+  if (!fsSync.existsSync(basedir)) {
+    warnLog(`Error resolving path: '${id}' : glslify may fail to find includes`);
+    basedir = process.cwd();
+  }
+
+  return glslifyCompile(source, /** @type {GlslifyOptions} */({basedir, ...options}));
+}