miniray 0.1.1

package/lib/browser.js

@@ -0,0 +1,177 @@
+/**
+ * miniray - WGSL Minifier for WebGPU Shaders (Browser Build)
+ *
+ * Usage:
+ *   import { initialize, minify } from 'miniray'
+ *   await initialize({ wasmURL: '/miniray.wasm' })
+ *   const result = minify(source, { minifyWhitespace: true })
+ */
+
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.miniray = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  let _initialized = false;
+  let _initPromise = null;
+  let _go = null;
+
+  /**
+   * Initialize the WASM module.
+   * @param {Object} options
+   * @param {string|URL} [options.wasmURL] - URL to miniray.wasm
+   * @param {WebAssembly.Module} [options.wasmModule] - Pre-compiled module
+   * @returns {Promise<void>}
+   */
+  async function initialize(options) {
+    if (_initialized) {
+      return;
+    }
+    if (_initPromise) {
+      return _initPromise;
+    }
+
+    options = options || {};
+    const wasmURL = options.wasmURL;
+    const wasmModule = options.wasmModule;
+
+    if (!wasmURL && !wasmModule) {
+      throw new Error('Must provide either wasmURL or wasmModule');
+    }
+
+    _initPromise = _doInitialize(wasmURL, wasmModule);
+
+    try {
+      await _initPromise;
+      _initialized = true;
+    } catch (err) {
+      _initPromise = null;
+      throw err;
+    }
+  }
+
+  async function _doInitialize(wasmURL, wasmModule) {
+    // Load wasm_exec.js if Go is not defined
+    if (typeof Go === 'undefined') {
+      throw new Error(
+        'Go runtime not found. Make sure to include wasm_exec.js before using miniray:\n' +
+        '<script src="wasm_exec.js"></script>'
+      );
+    }
+
+    _go = new Go();
+
+    let instance;
+    if (wasmModule) {
+      // Use pre-compiled module
+      instance = await WebAssembly.instantiate(wasmModule, _go.importObject);
+    } else {
+      // Fetch and instantiate
+      const url = wasmURL instanceof URL ? wasmURL.href : wasmURL;
+
+      if (typeof WebAssembly.instantiateStreaming === 'function') {
+        try {
+          const response = await fetch(url);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status}`);
+          }
+          const result = await WebAssembly.instantiateStreaming(response, _go.importObject);
+          instance = result.instance;
+        } catch (err) {
+          // Fall back to arrayBuffer if streaming fails (e.g., wrong MIME type)
+          if (err.message && err.message.includes('MIME')) {
+            const response = await fetch(url);
+            const bytes = await response.arrayBuffer();
+            const result = await WebAssembly.instantiate(bytes, _go.importObject);
+            instance = result.instance;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        // Fallback for older browsers
+        const response = await fetch(url);
+        const bytes = await response.arrayBuffer();
+        const result = await WebAssembly.instantiate(bytes, _go.importObject);
+        instance = result.instance;
+      }
+    }
+
+    // Run the Go program (this sets up __miniray global)
+    _go.run(instance);
+
+    // Wait for __miniray to be available
+    await _waitForGlobal('__miniray', 1000);
+  }
+
+  function _waitForGlobal(name, timeout) {
+    return new Promise((resolve, reject) => {
+      const start = Date.now();
+      const check = () => {
+        if (typeof globalThis[name] !== 'undefined') {
+          resolve();
+        } else if (Date.now() - start > timeout) {
+          reject(new Error(`Timeout waiting for ${name} to be defined`));
+        } else {
+          setTimeout(check, 10);
+        }
+      };
+      check();
+    });
+  }
+
+  /**
+   * Minify WGSL source code.
+   * @param {string} source - WGSL source code
+   * @param {Object} [options] - Minification options
+   * @param {boolean} [options.minifyWhitespace=true] - Remove whitespace
+   * @param {boolean} [options.minifyIdentifiers=true] - Rename identifiers
+   * @param {boolean} [options.minifySyntax=true] - Optimize syntax
+   * @param {boolean} [options.mangleExternalBindings=false] - Mangle uniform/storage names
+   * @param {string[]} [options.keepNames] - Names to preserve
+   * @returns {Object} Result with code, errors, originalSize, minifiedSize
+   */
+  function minify(source, options) {
+    if (!_initialized) {
+      throw new Error('miniray not initialized. Call initialize() first.');
+    }
+
+    if (typeof source !== 'string') {
+      throw new Error('source must be a string');
+    }
+
+    return globalThis.__miniray.minify(source, options || {});
+  }
+
+  /**
+   * Check if initialized.
+   * @returns {boolean}
+   */
+  function isInitialized() {
+    return _initialized;
+  }
+
+  /**
+   * Get version.
+   * @returns {string}
+   */
+  function getVersion() {
+    if (!_initialized) {
+      return 'unknown';
+    }
+    return globalThis.__miniray.version;
+  }
+
+  return {
+    initialize: initialize,
+    minify: minify,
+    isInitialized: isInitialized,
+    get version() { return getVersion(); }
+  };
+}));

package/lib/main.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Options for WGSL minification.
+ */
+export interface MinifyOptions {
+  /**
+   * Remove unnecessary whitespace and newlines.
+   * @default true
+   */
+  minifyWhitespace?: boolean;
+
+  /**
+   * Rename identifiers to shorter names.
+   * Entry points and API-facing declarations are preserved.
+   * @default true
+   */
+  minifyIdentifiers?: boolean;
+
+  /**
+   * Apply syntax-level optimizations (numeric literals, etc).
+   * @default true
+   */
+  minifySyntax?: boolean;
+
+  /**
+   * Rename uniform/storage variable declarations directly.
+   * When false (default), original names are preserved and short aliases are used.
+   * Set to true only if you don't use WebGPU's binding reflection APIs.
+   * @default false
+   */
+  mangleExternalBindings?: boolean;
+
+  /**
+   * Identifier names that should not be renamed.
+   */
+  keepNames?: string[];
+}
+
+/**
+ * Error information from minification.
+ */
+export interface MinifyError {
+  /** Error message */
+  message: string;
+  /** Line number (1-indexed, 0 if unknown) */
+  line: number;
+  /** Column number (1-indexed, 0 if unknown) */
+  column: number;
+}
+
+/**
+ * Result of minification.
+ */
+export interface MinifyResult {
+  /** Minified WGSL code */
+  code: string;
+  /** Errors encountered during minification */
+  errors: MinifyError[];
+  /** Size of input in bytes */
+  originalSize: number;
+  /** Size of output in bytes */
+  minifiedSize: number;
+}
+
+/**
+ * Options for initializing the WASM module.
+ */
+export interface InitializeOptions {
+  /**
+   * URL or path to the wgslmin.wasm file.
+   * Required unless wasmModule is provided.
+   */
+  wasmURL?: string | URL;
+
+  /**
+   * Pre-compiled WebAssembly.Module.
+   * Use this to share a module across multiple instances.
+   */
+  wasmModule?: WebAssembly.Module;
+}
+
+/**
+ * Initialize the WASM module. Must be called before minify().
+ * @param options - Initialization options
+ */
+export function initialize(options: InitializeOptions): Promise<void>;
+
+/**
+ * Minify WGSL source code.
+ * @param source - WGSL source code to minify
+ * @param options - Minification options (defaults to full minification)
+ * @returns Minification result
+ */
+export function minify(source: string, options?: MinifyOptions): MinifyResult;
+
+/**
+ * Check if the WASM module is initialized.
+ */
+export function isInitialized(): boolean;
+
+/**
+ * Get the version of the minifier.
+ */
+export const version: string;

package/lib/main.js

@@ -0,0 +1,152 @@
+/**
+ * miniray - WGSL Minifier for WebGPU Shaders (Node.js Build)
+ *
+ * Usage:
+ *   const { initialize, minify } = require('miniray')
+ *   await initialize()
+ *   const result = minify(source, { minifyWhitespace: true })
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+let _initialized = false;
+let _initPromise = null;
+let _go = null;
+
+/**
+ * Initialize the WASM module.
+ * @param {Object} options
+ * @param {string} [options.wasmURL] - Path to miniray.wasm
+ * @param {WebAssembly.Module} [options.wasmModule] - Pre-compiled module
+ * @returns {Promise<void>}
+ */
+async function initialize(options) {
+  if (_initialized) {
+    return;
+  }
+  if (_initPromise) {
+    return _initPromise;
+  }
+
+  options = options || {};
+  let wasmURL = options.wasmURL;
+  const wasmModule = options.wasmModule;
+
+  // Default to miniray.wasm in the package directory
+  if (!wasmURL && !wasmModule) {
+    wasmURL = path.join(__dirname, '..', 'miniray.wasm');
+  }
+
+  _initPromise = _doInitialize(wasmURL, wasmModule);
+
+  try {
+    await _initPromise;
+    _initialized = true;
+  } catch (err) {
+    _initPromise = null;
+    throw err;
+  }
+}
+
+async function _doInitialize(wasmURL, wasmModule) {
+  // Set up globals required by wasm_exec.js
+  globalThis.require = require;
+  globalThis.fs = require('fs');
+  globalThis.path = require('path');
+  globalThis.TextEncoder = require('util').TextEncoder;
+  globalThis.TextDecoder = require('util').TextDecoder;
+  globalThis.performance ??= require('perf_hooks').performance;
+  globalThis.crypto ??= require('crypto');
+
+  // Load wasm_exec.js to set up Go runtime
+  const wasmExecPath = path.join(__dirname, '..', 'wasm_exec.js');
+  if (!fs.existsSync(wasmExecPath)) {
+    throw new Error(`wasm_exec.js not found at ${wasmExecPath}`);
+  }
+  require(wasmExecPath);
+
+  if (typeof Go === 'undefined') {
+    throw new Error('Go runtime not found after loading wasm_exec.js');
+  }
+
+  _go = new Go();
+
+  let instance;
+  if (wasmModule) {
+    instance = await WebAssembly.instantiate(wasmModule, _go.importObject);
+  } else {
+    const wasmPath = wasmURL instanceof URL ? wasmURL.pathname : wasmURL;
+    const wasmBuffer = fs.readFileSync(wasmPath);
+    const result = await WebAssembly.instantiate(wasmBuffer, _go.importObject);
+    instance = result.instance;
+  }
+
+  // Run the Go program (don't await - it runs in background)
+  _go.run(instance);
+
+  // Wait for __miniray to be available
+  await _waitForGlobal('__miniray', 1000);
+}
+
+function _waitForGlobal(name, timeout) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (typeof global[name] !== 'undefined') {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject(new Error(`Timeout waiting for ${name} to be defined`));
+      } else {
+        setTimeout(check, 10);
+      }
+    };
+    check();
+  });
+}
+
+/**
+ * Minify WGSL source code.
+ * @param {string} source - WGSL source code
+ * @param {Object} [options] - Minification options
+ * @returns {Object} Result
+ */
+function minify(source, options) {
+  if (!_initialized) {
+    throw new Error('miniray not initialized. Call initialize() first.');
+  }
+
+  if (typeof source !== 'string') {
+    throw new Error('source must be a string');
+  }
+
+  return global.__miniray.minify(source, options || {});
+}
+
+/**
+ * Check if initialized.
+ * @returns {boolean}
+ */
+function isInitialized() {
+  return _initialized;
+}
+
+/**
+ * Get version.
+ * @returns {string}
+ */
+function getVersion() {
+  if (!_initialized) {
+    return 'unknown';
+  }
+  return global.__miniray.version;
+}
+
+module.exports = {
+  initialize,
+  minify,
+  isInitialized,
+  get version() { return getVersion(); }
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "miniray",
+  "version": "0.1.1",
+  "description": "WGSL minifier for WebGPU shaders - WebAssembly build",
+  "main": "lib/main.js",
+  "module": "esm/browser.js",
+  "browser": {
+    "./lib/main.js": "./lib/browser.js"
+  },
+  "types": "lib/main.d.ts",
+  "bin": {
+    "miniray": "bin/miniray"
+  },
+  "exports": {
+    ".": {
+      "browser": {
+        "import": "./esm/browser.js",
+        "default": "./lib/browser.js"
+      },
+      "node": {
+        "import": "./esm/node.mjs",
+        "require": "./lib/main.js"
+      },
+      "default": "./lib/main.js"
+    },
+    "./wasm": "./miniray.wasm"
+  },
+  "files": [
+    "lib",
+    "esm",
+    "bin",
+    "miniray.wasm",
+    "wasm_exec.js"
+  ],
+  "keywords": [
+    "wgsl",
+    "webgpu",
+    "minifier",
+    "shader",
+    "wasm",
+    "webassembly",
+    "gpu",
+    "miniray"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HugoDaniel/miniray"
+  },
+  "homepage": "https://github.com/HugoDaniel/miniray",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  }
+}