@bigmistqke/view.gl 0.1.7 → 0.1.9

package/test/tag.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { toID } from '../src'
 import { attribute, compile, glsl, interleave, uniform } from '../src/tag'
 import type { GL } from '../src/types'
 import { createMockGL } from './mocks/webgl'
@@ -628,13 +629,15 @@ void main() { gl_FragColor = vec4(0.5); }`
 
     compile(gl, glsl``, fragment)
 
-    // Check that shaderSource was called with symbol aliases in template
+    const colorAlias = toID(color_symbol)
+
+    // Check that shaderSource was called with exact symbol alias
     const fragmentShaderSource = (gl.shaderSource as any).mock.calls.find(
-      (call: any[]) => call[1].includes('vec3') && call[1].includes('VIEW_GL_ALIAS_')
+      (call: any[]) => call[1].includes(`vec3 ${colorAlias}`)
     )?.[1]
 
-    expect(fragmentShaderSource).toMatch(/vec3 VIEW_GL_ALIAS_\d+ = vec3/)
-    expect(fragmentShaderSource).toMatch(/vec4\(VIEW_GL_ALIAS_\d+, 1\.0\)/)
+    expect(fragmentShaderSource).toContain(`vec3 ${colorAlias} = vec3(1.0, 0.0, 0.0);`)
+    expect(fragmentShaderSource).toContain(`gl_FragColor = vec4(${colorAlias}, 1.0);`)
   })
 })
 
@@ -1485,6 +1488,693 @@ describe('compile', () => {
     expect(schema.uniforms[u_vertex_only]).toEqual({ kind: 'vec2' })
     expect(schema.uniforms[u_fragment_only]).toEqual({ kind: 'vec3' })
   })
+
+  it('should return compiled vertex and fragment shader strings', () => {
+    const vertex = glsl`
+      ${attribute.vec2('a_position')}
+      ${uniform.mat4('u_mvpMatrix')}
+      
+      void main() {
+        gl_Position = u_mvpMatrix * vec4(a_position, 0.0, 1.0);
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      ${uniform.vec4('u_color')}
+      
+      void main() {
+        gl_FragColor = u_color;
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Check vertex shader string
+    expect(result.vertex).toContain('attribute vec2 a_position;')
+    expect(result.vertex).toContain('uniform mat4 u_mvpMatrix;')
+    expect(result.vertex).toContain('gl_Position = u_mvpMatrix * vec4(a_position, 0.0, 1.0);')
+
+    // Check fragment shader string
+    expect(result.fragment).toContain('precision mediump float;')
+    expect(result.fragment).toContain('uniform vec4 u_color;')
+    expect(result.fragment).toContain('gl_FragColor = u_color;')
+  })
+
+  it('should return WebGL2 shader strings with proper syntax', () => {
+    const vertex = glsl`#version 300 es
+      ${attribute.vec3('a_position')}
+      ${attribute.vec3('a_normal')}
+      out vec3 v_normal;
+      
+      void main() {
+        v_normal = a_normal;
+        gl_Position = vec4(a_position, 1.0);
+      }
+    `
+
+    const fragment = glsl`#version 300 es
+      precision mediump float;
+      ${uniform.vec3('u_lightDir')}
+      in vec3 v_normal;
+      out vec4 fragColor;
+      
+      void main() {
+        float light = dot(v_normal, u_lightDir);
+        fragColor = vec4(vec3(light), 1.0);
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Check vertex uses 'in' for attributes in WebGL2
+    expect(result.vertex).toContain('in vec3 a_position;')
+    expect(result.vertex).toContain('in vec3 a_normal;')
+    expect(result.vertex).toContain('out vec3 v_normal;')
+
+    // Check fragment shader WebGL2 syntax
+    expect(result.fragment).toContain('#version 300 es')
+    expect(result.fragment).toContain('in vec3 v_normal;')
+    expect(result.fragment).toContain('out vec4 fragColor;')
+  })
+
+  it('should return shader strings with resolved symbols', () => {
+    const u_time_symbol = Symbol('u_time')
+    const a_pos_symbol = Symbol('a_position')
+
+    const vertex = glsl`
+      ${attribute.vec3(a_pos_symbol)}
+      ${uniform.float(u_time_symbol)}
+      
+      void main() {
+        gl_Position = vec4(${a_pos_symbol}, ${u_time_symbol});
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      ${uniform.float(u_time_symbol)}
+      
+      void main() {
+        gl_FragColor = vec4(${u_time_symbol});
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Get exact symbol aliases
+    const posAlias = toID(a_pos_symbol)
+    const timeAlias = toID(u_time_symbol)
+
+    // Check vertex shader contains expected exact strings
+    expect(result.vertex).toContain(`attribute vec3 ${posAlias};`)
+    expect(result.vertex).toContain(`uniform float ${timeAlias};`)
+    expect(result.vertex).toContain(`gl_Position = vec4(${posAlias}, ${timeAlias});`)
+
+    // Check fragment shader contains expected exact strings
+    expect(result.fragment).toContain(`uniform float ${timeAlias};`)
+    expect(result.fragment).toContain(`gl_FragColor = vec4(${timeAlias});`)
+    expect(result.fragment).toContain('precision mediump float;')
+  })
+
+  it('should return shader strings with interleaved attributes', () => {
+    const vertex = glsl`
+      ${interleave('vertexData', [
+        attribute.vec3('a_position'),
+        attribute.vec2('a_uv'),
+        attribute.vec3('a_normal')
+      ])}
+      
+      void main() {
+        gl_Position = vec4(a_position + a_normal, 0.0, 1.0);
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      
+      void main() {
+        gl_FragColor = vec4(1.0);
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Check all interleaved attributes are expanded in vertex shader
+    expect(result.vertex).toContain('attribute vec3 a_position;')
+    expect(result.vertex).toContain('attribute vec2 a_uv;')
+    expect(result.vertex).toContain('attribute vec3 a_normal;')
+    expect(result.vertex).toContain('gl_Position = vec4(a_position + a_normal, 0.0, 1.0);')
+
+    // Fragment shader should be returned as-is
+    expect(result.fragment).toContain('precision mediump float;')
+    expect(result.fragment).toContain('gl_FragColor = vec4(1.0);')
+  })
+
+  it('should return shader strings with composed GLSL fragments', () => {
+    const sharedUniforms = glsl`
+      ${uniform.float('u_time')}
+      ${uniform.vec2('u_resolution')}
+    `
+
+    const utils = glsl`
+      float rand(vec2 co) {
+        return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
+      }
+    `
+
+    const vertex = glsl`
+      ${sharedUniforms}
+      ${attribute.vec2('a_position')}
+      
+      void main() {
+        gl_Position = vec4(a_position * u_resolution, 0.0, 1.0);
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      ${sharedUniforms}
+      ${utils}
+      
+      void main() {
+        float r = rand(gl_FragCoord.xy * u_time);
+        gl_FragColor = vec4(r);
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Check vertex shader includes composed uniforms
+    expect(result.vertex).toContain('uniform float u_time;')
+    expect(result.vertex).toContain('uniform vec2 u_resolution;')
+    expect(result.vertex).toContain('attribute vec2 a_position;')
+
+    // Check fragment shader includes both uniforms and utils
+    expect(result.fragment).toContain('uniform float u_time;')
+    expect(result.fragment).toContain('uniform vec2 u_resolution;')
+    expect(result.fragment).toContain('float rand(vec2 co)')
+    expect(result.fragment).toContain('return fract(sin(dot(co.xy')
+  })
+
+  it('should return shader strings with array interpolations', () => {
+    const vertex = glsl`
+      ${[
+        uniform.mat4('u_model'),
+        uniform.mat4('u_view'),
+        uniform.mat4('u_projection')
+      ]}
+      ${[attribute.vec3('a_position'), attribute.vec3('a_normal')]}
+      
+      void main() {
+        gl_Position = u_projection * u_view * u_model * vec4(a_position, 1.0);
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      ${[uniform.vec3('u_color'), uniform.float('u_alpha')]}
+      
+      void main() {
+        gl_FragColor = vec4(u_color, u_alpha);
+      }
+    `
+
+    const result = compile(gl, vertex, fragment)
+
+    // Check vertex shader has all uniforms and attributes from arrays
+    expect(result.vertex).toContain('uniform mat4 u_model;')
+    expect(result.vertex).toContain('uniform mat4 u_view;')
+    expect(result.vertex).toContain('uniform mat4 u_projection;')
+    expect(result.vertex).toContain('attribute vec3 a_position;')
+    expect(result.vertex).toContain('attribute vec3 a_normal;')
+
+    // Check fragment shader
+    expect(result.fragment).toContain('uniform vec3 u_color;')
+    expect(result.fragment).toContain('uniform float u_alpha;')
+  })
+})
+
+describe('compile.toQuad', () => {
+  let gl: GL
+  let mockProgram: WebGLProgram
+
+  beforeEach(() => {
+    gl = createMockGL()
+    mockProgram = gl.createProgram()!
+
+    // Mock shader creation and compilation
+    gl.createShader = vi.fn(type => ({ type } as WebGLShader))
+    gl.shaderSource = vi.fn()
+    gl.compileShader = vi.fn()
+    gl.getShaderParameter = vi.fn(() => true)
+    gl.attachShader = vi.fn()
+    gl.linkProgram = vi.fn()
+    gl.getProgramParameter = vi.fn(() => true)
+    gl.createProgram = vi.fn(() => mockProgram)
+    gl.createBuffer = vi.fn(() => ({} as WebGLBuffer))
+    gl.bindBuffer = vi.fn()
+    gl.bufferData = vi.fn()
+  })
+
+  it('should create a quad with fragment shader only', () => {
+    const fragment = glsl`
+      precision mediump float;
+      ${uniform.float('u_time')}
+      ${uniform.vec2('u_resolution')}
+      
+      in vec2 uv;
+      out vec4 fragColor;
+      
+      void main() {
+        vec2 pos = uv * u_resolution;
+        float pattern = sin(pos.x * 0.01 + u_time) * sin(pos.y * 0.01 + u_time);
+        fragColor = vec4(vec3(pattern), 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.program).toBe(mockProgram)
+    
+    // Should have quad attribute in schema
+    expect(result.schema.attributes).toEqual({
+      a_quad: { kind: 'vec2', buffer: expect.any(Object) }
+    })
+    
+    // Should have fragment uniforms
+    expect(result.schema.uniforms).toEqual({
+      u_time: { kind: 'float' },
+      u_resolution: { kind: 'vec2' }
+    })
+  })
+
+  it('should generate vertex shader with correct uv output', () => {
+    const fragment = glsl`#version 300 es
+      precision mediump float;
+      ${uniform.vec3('u_color')}
+      
+      in vec2 v_uv;
+      out vec4 fragColor;
+      
+      void main() {
+        fragColor = vec4(u_color * v_uv.x, 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    // Check that vertex shader contains expected content
+    expect(result.vertex).toContain('#version 300 es')
+    expect(result.vertex).toContain('in vec2 a_quad;')
+    expect(result.vertex).toContain('out vec2 v_uv;')
+    expect(result.vertex).toContain('v_uv = a_quad;')
+    expect(result.vertex).toContain('gl_Position = vec4(v_uv, 0.0, 1.0);')
+  })
+
+  it('should handle fragment shader with multiple uniforms', () => {
+    const fragment = glsl`#version 300 es
+      precision mediump float;
+      
+      ${uniform.float('u_time')}
+      ${uniform.vec2('u_resolution')}
+      ${uniform.vec3('u_color')}
+      ${uniform.sampler2D('u_texture')}
+      
+      in vec2 uv;
+      out vec4 fragColor;
+      
+      void main() {
+        vec2 pos = uv * u_resolution + u_time;
+        vec4 tex = texture(u_texture, pos);
+        fragColor = vec4(u_color * tex.rgb, 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.schema.uniforms).toEqual({
+      u_time: { kind: 'float' },
+      u_resolution: { kind: 'vec2' },
+      u_color: { kind: 'vec3' },
+      u_texture: { kind: 'sampler2D' }
+    })
+
+    expect(result.schema.attributes).toEqual({
+      a_quad: { kind: 'vec2', buffer: expect.any(Object) }
+    })
+  })
+
+  it('should automatically set up quad buffer data', () => {
+    const fragment = glsl`
+      precision mediump float;
+      void main() { gl_FragColor = vec4(1.0); }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    // Check that buffer was created and data was set
+    expect(gl.createBuffer).toHaveBeenCalled()
+    expect(gl.bindBuffer).toHaveBeenCalled()
+    expect(gl.bufferData).toHaveBeenCalled()
+
+    // Verify the quad data contains correct triangle vertices
+    const bufferDataCall = (gl.bufferData as any).mock.calls[0]
+    const quadData = bufferDataCall[1] as Float32Array
+    
+    // Should contain 6 vertices for 2 triangles forming a quad
+    expect(quadData.length).toBe(12) // 6 vertices * 2 components
+    expect(Array.from(quadData)).toEqual([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1])
+  })
+
+  it('should work with ray-marching fragment shader', () => {
+    const fragment = glsl`#version 300 es
+      precision mediump float;
+      
+      ${uniform.float('u_time')}
+      ${uniform.vec2('u_resolution')}
+      ${uniform.vec3('u_cameraPos')}
+      
+      in vec2 uv;
+      out vec4 fragColor;
+      
+      float sdSphere(vec3 pos, float radius) {
+        return length(pos) - radius;
+      }
+      
+      void main() {
+        vec2 screenPos = uv * u_resolution;
+        vec3 rayDir = normalize(vec3(screenPos, -1.0));
+        
+        float dist = sdSphere(u_cameraPos, 1.0);
+        vec3 color = vec3(smoothstep(0.0, 0.1, dist));
+        
+        fragColor = vec4(color, 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.schema.uniforms).toEqual({
+      u_time: { kind: 'float' },
+      u_resolution: { kind: 'vec2' },
+      u_cameraPos: { kind: 'vec3' }
+    })
+
+    // Should compile without errors
+    expect(result.program).toBe(mockProgram)
+    expect(result.vertex).toContain('in vec2 a_quad;')
+    expect(result.fragment).toContain('float sdSphere')
+  })
+
+  it('should support options parameter', () => {
+    const fragment = glsl`
+      precision mediump float;
+      ${uniform.float('u_time')}
+      void main() { gl_FragColor = vec4(1.0); }
+    `
+
+    const options = {
+      schema: {
+        uniforms: {
+          u_customUniform: { kind: 'vec3' as const }
+        }
+      }
+    }
+
+    const result = compile.toQuad(gl, fragment, options)
+
+    // Should merge the custom schema
+    expect(result.schema.uniforms).toEqual({
+      u_time: { kind: 'float' },
+      u_customUniform: { kind: 'vec3' }
+    })
+  })
+
+  it('should handle fragment shader with symbol uniforms', () => {
+    const u_time_symbol = Symbol('u_time')
+    const u_color_symbol = Symbol('u_color')
+
+    const fragment = glsl`
+      precision mediump float;
+      
+      ${uniform.float(u_time_symbol)}
+      ${uniform.vec3(u_color_symbol)}
+      
+      in vec2 uv;
+      out vec4 fragColor;
+      
+      void main() {
+        float wave = sin(${u_time_symbol} + uv.x * 10.0);
+        fragColor = vec4(${u_color_symbol} * wave, 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.schema.uniforms).toEqual({
+      [u_time_symbol]: { kind: 'float' },
+      [u_color_symbol]: { kind: 'vec3' }
+    })
+  })
+
+  it('should handle fragment shader with composed GLSL', () => {
+    const commonUniforms = glsl`
+      ${uniform.float('u_time')}
+      ${uniform.vec2('u_resolution')}
+    `
+
+    const noiseCode = glsl`
+      float random(vec2 st) {
+        return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
+      }
+    `
+
+    const fragment = glsl`
+      precision mediump float;
+      
+      ${commonUniforms}
+      ${noiseCode}
+      
+      in vec2 uv;
+      out vec4 fragColor;
+      
+      void main() {
+        float noise = random(uv * u_resolution + u_time);
+        fragColor = vec4(vec3(noise), 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.schema.uniforms).toEqual({
+      u_time: { kind: 'float' },
+      u_resolution: { kind: 'vec2' }
+    })
+
+    expect(result.fragment).toContain('float random(vec2 st)')
+  })
+
+  it('should work with empty fragment shader', () => {
+    const fragment = glsl`
+      precision mediump float;
+      void main() {
+        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+      }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    expect(result.schema.uniforms).toEqual({})
+    expect(result.schema.attributes).toEqual({
+      a_quad: { kind: 'vec2', buffer: expect.any(Object) }
+    })
+    expect(result.program).toBe(mockProgram)
+  })
+
+  it('should reuse buffers across multiple calls', () => {
+    const fragment1 = glsl`void main() { gl_FragColor = vec4(1.0); }`
+    const fragment2 = glsl`void main() { gl_FragColor = vec4(0.5); }`
+
+    compile.toQuad(gl, fragment1)
+    compile.toQuad(gl, fragment2)
+
+    // Buffer should only be created once (reused)
+    expect(gl.createBuffer).toHaveBeenCalledTimes(1)
+  })
+
+  it('should expose quad attribute in view for binding', () => {
+    const fragment = glsl`
+      precision mediump float;
+      void main() { gl_FragColor = vec4(1.0); }
+    `
+
+    const result = compile.toQuad(gl, fragment)
+
+    // The view should have the a_quad attribute available
+    expect('a_quad' in result.view.attributes).toBe(true)
+  })
+
+  describe('WebGL version detection', () => {
+    it('should generate WebGL1 vertex shader for fragment without version directive', () => {
+      const fragment = glsl`
+        precision mediump float;
+        ${uniform.float('u_time')}
+        
+        varying vec2 v_uv;
+        
+        void main() {
+          gl_FragColor = vec4(v_uv, u_time, 1.0);
+        }
+      `
+
+      const result = compile.toQuad(gl, fragment)
+
+      // Should generate WebGL1 vertex shader
+      expect(result.vertex).not.toContain('#version 300 es')
+      expect(result.vertex).toContain('attribute vec2 a_quad;')
+      expect(result.vertex).toContain('varying vec2 v_uv;')
+      expect(result.vertex).not.toContain('in vec2 a_quad;')
+      expect(result.vertex).not.toContain('out vec2 v_uv;')
+    })
+
+    it('should generate WebGL2 vertex shader for fragment with #version 300 es', () => {
+      const fragment = glsl`#version 300 es
+        precision mediump float;
+        ${uniform.float('u_time')}
+        
+        in vec2 v_uv;
+        out vec4 fragColor;
+        
+        void main() {
+          fragColor = vec4(v_uv, u_time, 1.0);
+        }
+      `
+
+      const result = compile.toQuad(gl, fragment)
+
+      // Should generate WebGL2 vertex shader
+      expect(result.vertex).toContain('#version 300 es')
+      expect(result.vertex).toContain('in vec2 a_quad;')
+      expect(result.vertex).toContain('out vec2 v_uv;')
+      expect(result.vertex).not.toContain('attribute vec2 a_quad;')
+      expect(result.vertex).not.toContain('varying vec2 v_uv;')
+    })
+
+    it('should respect explicit webgl2 option over fragment version detection', () => {
+      const fragment = glsl`
+        precision mediump float;
+        ${uniform.float('u_time')}
+        
+        void main() {
+          gl_FragColor = vec4(u_time);
+        }
+      `
+
+      // Force WebGL2 despite no version directive in fragment
+      const result = compile.toQuad(gl, fragment, { webgl2: true })
+
+      // Should generate WebGL2 vertex shader
+      expect(result.vertex).toContain('#version 300 es')
+      expect(result.vertex).toContain('in vec2 a_quad;')
+      expect(result.vertex).toContain('out vec2 v_uv;')
+    })
+
+    it('should respect explicit webgl2: false option over fragment version detection', () => {
+      const fragment = glsl`#version 300 es
+        precision mediump float;
+        ${uniform.float('u_time')}
+        
+        in vec2 v_uv;
+        out vec4 fragColor;
+        
+        void main() {
+          fragColor = vec4(u_time);
+        }
+      `
+
+      // Force WebGL1 despite version directive in fragment
+      const result = compile.toQuad(gl, fragment, { webgl2: false })
+
+      // Should generate WebGL1 vertex shader
+      expect(result.vertex).not.toContain('#version 300 es')
+      expect(result.vertex).toContain('attribute vec2 a_quad;')
+      expect(result.vertex).toContain('varying vec2 v_uv;')
+    })
+
+    it('should handle fragment with mixed content and version detection', () => {
+      const commonUniforms = glsl`
+        ${uniform.float('u_time')}
+        ${uniform.vec2('u_resolution')}
+      `
+
+      const fragment = glsl`#version 300 es
+        precision mediump float;
+        
+        ${commonUniforms}
+        
+        in vec2 v_uv;
+        out vec4 fragColor;
+        
+        void main() {
+          vec2 uv = v_uv * u_resolution;
+          fragColor = vec4(sin(uv.x + u_time), cos(uv.y + u_time), 0.5, 1.0);
+        }
+      `
+
+      const result = compile.toQuad(gl, fragment)
+
+      // Should detect WebGL2 from version directive
+      expect(result.vertex).toContain('#version 300 es')
+      expect(result.vertex).toContain('in vec2 a_quad;')
+      expect(result.vertex).toContain('out vec2 v_uv;')
+
+      // Should preserve fragment uniforms
+      expect(result.schema.uniforms).toEqual({
+        u_time: { kind: 'float' },
+        u_resolution: { kind: 'vec2' }
+      })
+    })
+
+    it('should work with WebGL1 fragment containing complex shader logic', () => {
+      const lightingCode = glsl`
+        vec3 calculateLighting(vec3 normal, vec3 lightDir) {
+          return max(dot(normal, lightDir), 0.0) * vec3(1.0);
+        }
+      `
+
+      const fragment = glsl`
+        precision mediump float;
+        
+        ${uniform.vec3('u_lightPos')}
+        ${uniform.vec3('u_color')}
+        ${lightingCode}
+        
+        varying vec2 v_uv;
+        
+        void main() {
+          vec3 normal = normalize(vec3(v_uv, 1.0));
+          vec3 lightDir = normalize(u_lightPos);
+          vec3 lighting = calculateLighting(normal, lightDir);
+          gl_FragColor = vec4(u_color * lighting, 1.0);
+        }
+      `
+
+      const result = compile.toQuad(gl, fragment)
+
+      // Should generate WebGL1 vertex shader
+      expect(result.vertex).not.toContain('#version 300 es')
+      expect(result.vertex).toContain('attribute vec2 a_quad;')
+      expect(result.vertex).toContain('varying vec2 v_uv;')
+      
+      // Should preserve composed GLSL and uniforms
+      expect(result.fragment).toContain('calculateLighting')
+      expect(result.schema.uniforms).toEqual({
+        u_lightPos: { kind: 'vec3' },
+        u_color: { kind: 'vec3' }
+      })
+    })
+  })
 })
 
 describe('compile.toString', () => {
@@ -1544,9 +2234,10 @@ describe('compile.toString', () => {
       }`
 
     const result = compile.toString(shader)
+    const timeAlias = toID(u_time_symbol)
 
-    expect(result).toMatch(/uniform float VIEW_GL_ALIAS_\d+;/)
-    expect(result).toMatch(/vec4\(VIEW_GL_ALIAS_\d+\)/)
+    expect(result).toContain(`uniform float ${timeAlias};`)
+    expect(result).toContain(`gl_FragColor = vec4(${timeAlias});`)
   })
 
   it('should handle interleaved attributes', () => {