@razorpay/blade 12.92.0 → 12.93.0

package/build/lib/web/development/components/Spark/RazorSenseGradient/FluidGradientMount.js

@@ -0,0 +1,110 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { createProgram, setupFullscreenQuad } from '../RzpGlass/webgl-utils.js';
+import { FLUID_GRADIENT_LOOP, fragmentShader } from './shader.js';
+
+var vertexShader = /* glsl */"\n  precision mediump float;\n  attribute vec2 position;\n  attribute vec2 uv;\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = vec4(position, 0, 1);\n  }\n";
+var FluidGradientMount = /*#__PURE__*/function () {
+  function FluidGradientMount(parentElement, size) {
+    var _this = this;
+    var origin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [0.5, 0.5];
+    _classCallCheck(this, FluidGradientMount);
+    _defineProperty(this, "gl", null);
+    _defineProperty(this, "program", null);
+    _defineProperty(this, "buffers", null);
+    _defineProperty(this, "rafId", null);
+    // Uniform locations
+    _defineProperty(this, "uTimeLoc", null);
+    _defineProperty(this, "uOriginLoc", null);
+    _defineProperty(this, "hasBeenDisposed", false);
+    _defineProperty(this, "render", function (t) {
+      if (_this.hasBeenDisposed || !_this.gl) return;
+      _this.rafId = requestAnimationFrame(_this.render);
+      _this.gl.uniform1f(_this.uTimeLoc, t * 0.001 % FLUID_GRADIENT_LOOP);
+      _this.gl.drawArrays(_this.gl.TRIANGLES, 0, 6);
+    });
+    this.parentElement = parentElement;
+    var dpr = Math.min(window.devicePixelRatio, 2);
+    var pixelSize = Math.round(size * dpr);
+    this.canvasElement = document.createElement('canvas');
+    this.canvasElement.width = pixelSize;
+    this.canvasElement.height = pixelSize;
+    this.canvasElement.style.display = 'block';
+    this.canvasElement.style.width = "".concat(size, "px");
+    this.canvasElement.style.height = "".concat(size, "px");
+    parentElement.appendChild(this.canvasElement);
+    var gl = this.canvasElement.getContext('webgl', {
+      antialias: false,
+      powerPreference: 'high-performance',
+      alpha: true
+    });
+    if (!gl) {
+      console.error('FluidGradientMount: WebGL not supported');
+      return;
+    }
+    this.gl = gl;
+    this.setup(gl, pixelSize, origin);
+    this.rafId = requestAnimationFrame(this.render);
+  }
+  return _createClass(FluidGradientMount, [{
+    key: "setup",
+    value: function setup(gl, pixelSize, origin) {
+      var program = createProgram(gl, vertexShader, fragmentShader);
+      if (!program) return;
+      this.program = program;
+      var buffers = setupFullscreenQuad(gl, program);
+      if (!buffers) {
+        gl.deleteProgram(program);
+        this.program = null;
+        return;
+      }
+      this.buffers = buffers;
+      gl.useProgram(program);
+      gl.viewport(0, 0, pixelSize, pixelSize);
+      gl.disable(gl.DEPTH_TEST);
+      this.uTimeLoc = gl.getUniformLocation(program, 'uTime');
+      this.uOriginLoc = gl.getUniformLocation(program, 'uOrigin');
+      var iResolutionLoc = gl.getUniformLocation(program, 'iResolution');
+      gl.uniform2f(iResolutionLoc, pixelSize, pixelSize);
+      gl.uniform2f(this.uOriginLoc, origin[0], origin[1]);
+    }
+  }, {
+    key: "setOrigin",
+    value: /** Update the gradient origin in UV space without re-initialising WebGL. */
+    function setOrigin(origin) {
+      if (!this.gl || !this.uOriginLoc) return;
+      this.gl.uniform2f(this.uOriginLoc, origin[0], origin[1]);
+    }
+
+    /** Tear down the render loop, release all WebGL resources, and remove the canvas. */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.hasBeenDisposed = true;
+      if (this.rafId !== null) {
+        cancelAnimationFrame(this.rafId);
+        this.rafId = null;
+      }
+      if (this.gl) {
+        var _this$gl$getExtension;
+        if (this.program) {
+          this.gl.deleteProgram(this.program);
+          this.program = null;
+        }
+        if (this.buffers) {
+          this.gl.deleteBuffer(this.buffers.positionBuffer);
+          this.gl.deleteBuffer(this.buffers.uvBuffer);
+          this.buffers = null;
+        }
+        (_this$gl$getExtension = this.gl.getExtension('WEBGL_lose_context')) === null || _this$gl$getExtension === void 0 || _this$gl$getExtension.loseContext();
+      }
+      if (this.parentElement.contains(this.canvasElement)) {
+        this.parentElement.removeChild(this.canvasElement);
+      }
+    }
+  }]);
+}();
+
+export { FluidGradientMount };
+//# sourceMappingURL=FluidGradientMount.js.map

package/build/lib/web/development/components/Spark/RazorSenseGradient/FluidGradientMount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidGradientMount.js","sources":["../../../../../../../src/components/Spark/RazorSenseGradient/FluidGradientMount.ts"],"sourcesContent":["/**\n * FluidGradientMount\n *\n * Vanilla class that owns the full WebGL lifecycle for the fluid gradient effect.\n * Modelled after RzpGlassMount — create it with a parent element, call setOrigin()\n * to update the gradient origin reactively, and dispose() to clean up.\n */\n\nimport type { FullscreenQuadBuffers } from '../RzpGlass/webgl-utils';\nimport { createProgram, setupFullscreenQuad } from '../RzpGlass/webgl-utils';\nimport { fragmentShader, FLUID_GRADIENT_LOOP } from './shader';\n\nconst vertexShader = /* glsl */ `\n  precision mediump float;\n  attribute vec2 position;\n  attribute vec2 uv;\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = vec4(position, 0, 1);\n  }\n`;\n\nexport class FluidGradientMount {\n  public readonly canvasElement: HTMLCanvasElement;\n\n  private readonly parentElement: HTMLElement;\n  private readonly gl: WebGLRenderingContext | null = null;\n\n  private program: WebGLProgram | null = null;\n  private buffers: FullscreenQuadBuffers | null = null;\n  private rafId: number | null = null;\n\n  // Uniform locations\n  private uTimeLoc: WebGLUniformLocation | null = null;\n  private uOriginLoc: WebGLUniformLocation | null = null;\n\n  private hasBeenDisposed = false;\n\n  constructor(parentElement: HTMLElement, size: number, origin: [number, number] = [0.5, 0.5]) {\n    this.parentElement = parentElement;\n\n    const dpr = Math.min(window.devicePixelRatio, 2);\n    const pixelSize = Math.round(size * dpr);\n\n    this.canvasElement = document.createElement('canvas');\n    this.canvasElement.width = pixelSize;\n    this.canvasElement.height = pixelSize;\n    this.canvasElement.style.display = 'block';\n    this.canvasElement.style.width = `${size}px`;\n    this.canvasElement.style.height = `${size}px`;\n    parentElement.appendChild(this.canvasElement);\n\n    const gl = this.canvasElement.getContext('webgl', {\n      antialias: false,\n      powerPreference: 'high-performance',\n      alpha: true,\n    });\n\n    if (!gl) {\n      console.error('FluidGradientMount: WebGL not supported');\n      return;\n    }\n\n    this.gl = gl;\n    this.setup(gl, pixelSize, origin);\n    this.rafId = requestAnimationFrame(this.render);\n  }\n\n  private setup(gl: WebGLRenderingContext, pixelSize: number, origin: [number, number]): void {\n    const program = createProgram(gl, vertexShader, fragmentShader);\n    if (!program) return;\n    this.program = program;\n\n    const buffers = setupFullscreenQuad(gl, program);\n    if (!buffers) {\n      gl.deleteProgram(program);\n      this.program = null;\n      return;\n    }\n    this.buffers = buffers;\n\n    gl.useProgram(program);\n    gl.viewport(0, 0, pixelSize, pixelSize);\n    gl.disable(gl.DEPTH_TEST);\n\n    this.uTimeLoc = gl.getUniformLocation(program, 'uTime');\n    this.uOriginLoc = gl.getUniformLocation(program, 'uOrigin');\n    const iResolutionLoc = gl.getUniformLocation(program, 'iResolution');\n\n    gl.uniform2f(iResolutionLoc, pixelSize, pixelSize);\n    gl.uniform2f(this.uOriginLoc, origin[0], origin[1]);\n  }\n\n  private render = (t: number): void => {\n    if (this.hasBeenDisposed || !this.gl) return;\n    this.rafId = requestAnimationFrame(this.render);\n    this.gl.uniform1f(this.uTimeLoc, (t * 0.001) % FLUID_GRADIENT_LOOP);\n    this.gl.drawArrays(this.gl.TRIANGLES, 0, 6);\n  };\n\n  /** Update the gradient origin in UV space without re-initialising WebGL. */\n  public setOrigin(origin: [number, number]): void {\n    if (!this.gl || !this.uOriginLoc) return;\n    this.gl.uniform2f(this.uOriginLoc, origin[0], origin[1]);\n  }\n\n  /** Tear down the render loop, release all WebGL resources, and remove the canvas. */\n  public dispose(): void {\n    this.hasBeenDisposed = true;\n\n    if (this.rafId !== null) {\n      cancelAnimationFrame(this.rafId);\n      this.rafId = null;\n    }\n\n    if (this.gl) {\n      if (this.program) {\n        this.gl.deleteProgram(this.program);\n        this.program = null;\n      }\n      if (this.buffers) {\n        this.gl.deleteBuffer(this.buffers.positionBuffer);\n        this.gl.deleteBuffer(this.buffers.uvBuffer);\n        this.buffers = null;\n      }\n      this.gl.getExtension('WEBGL_lose_context')?.loseContext();\n    }\n\n    if (this.parentElement.contains(this.canvasElement)) {\n      this.parentElement.removeChild(this.canvasElement);\n    }\n  }\n}\n"],"names":["vertexShader","FluidGradientMount","parentElement","size","_this","origin","arguments","length","undefined","_classCallCheck","_defineProperty","t","hasBeenDisposed","gl","rafId","requestAnimationFrame","render","uniform1f","uTimeLoc","FLUID_GRADIENT_LOOP","drawArrays","TRIANGLES","dpr","Math","min","window","devicePixelRatio","pixelSize","round","canvasElement","document","createElement","width","height","style","display","concat","appendChild","getContext","antialias","powerPreference","alpha","console","error","setup","_createClass","key","value","program","createProgram","fragmentShader","buffers","setupFullscreenQuad","deleteProgram","useProgram","viewport","disable","DEPTH_TEST","getUniformLocation","uOriginLoc","iResolutionLoc","uniform2f","setOrigin","dispose","cancelAnimationFrame","_this$gl$getExtension","deleteBuffer","positionBuffer","uvBuffer","getExtension","loseContext","contains","removeChild"],"mappings":"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"}

package/build/lib/web/development/components/Spark/RazorSenseGradient/index.js

@@ -0,0 +1,2 @@
+export { FluidGradient as RazorSenseGradient } from './FluidGradient.js';
+//# sourceMappingURL=index.js.map

package/build/lib/web/development/components/Spark/RazorSenseGradient/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/build/lib/web/development/components/Spark/RazorSenseGradient/shader.js

@@ -0,0 +1,18 @@
+var FLUID_GRADIENT_LOOP = 12.0;
+
+// vec3 c0 = vec3(0.55, 0.95, 0.75);
+// vec3 c1 = vec3(0.35, 0.90, 0.65);
+// vec3 c2 = vec3(0.20, 0.88, 0.70);
+// vec3 c3 = vec3(0.08, 0.82, 0.48);
+// vec3 c4 = vec3(0.04, 0.68, 0.30);
+
+// vec3 c0 = vec3(0.72, 0.92, 1.00); // light sky blue
+// vec3 c1 = vec3(0.38, 0.72, 0.98); // cornflower blue
+// vec3 c2 = vec3(0.16, 0.50, 0.92); // medium blue
+// vec3 c3 = vec3(0.08, 0.30, 0.78); // deep royal blue
+// vec3 c4 = vec3(0.10, 0.28, 0.72); // deep blue (not black)
+
+var fragmentShader = /* glsl */"\nprecision mediump float;\n\nuniform float uTime;    // pre-wrapped: mod(raw, LOOP)\nuniform vec2  iResolution;\nuniform vec2  uOrigin;  // gradient origin in UV space (0,0)=top-left (1,1)=bottom-right\nvarying vec2 vUv;\n\n// Cubic smoothstep inside each segment \u2014 no kink at stop boundaries\nvec3 gradientColor(float t) {\n  t = clamp(t, 0.0, 1.0);\n  vec3 c0 = vec3(0.682, 0.957, 0.831);  // 174, 244, 212\n  vec3 c1 = vec3(0.310, 0.882, 0.620);  //  79, 225, 158\n  vec3 c2 = vec3(0.306, 0.973, 0.910);  //  78, 248, 232\n  vec3 c3 = vec3(0.004, 0.753, 0.443);  //   1, 192, 113\n  vec3 c4 = vec3(0.004, 0.753, 0.443);  //   1, 192, 113\n  float s;\n  if (t < 0.25) { s = smoothstep(0.0,1.0, t/0.25);         return mix(c0,c1,s); }\n  if (t < 0.55) { s = smoothstep(0.0,1.0,(t-0.25)/0.30);   return mix(c1,c2,s); }\n  if (t < 0.80) { s = smoothstep(0.0,1.0,(t-0.55)/0.25);   return mix(c2,c3,s); }\n                  s = smoothstep(0.0,1.0,(t-0.80)/0.20);   return mix(c3,c4,s);\n}\n\n// Value noise\nfloat hash(vec2 p) { return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453); }\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p), f = fract(p);\n  vec2 u = f*f*(3.0-2.0*f);\n  return mix(mix(hash(i),hash(i+vec2(1,0)),u.x), mix(hash(i+vec2(0,1)),hash(i+vec2(1,1)),u.x),u.y);\n}\n\nvoid main() {\n  vec2 uv = vUv - uOrigin;\n  float angle = atan(uv.y, uv.x);\n  float r = length(uv);\n\n  // Warp: traces a circle in noise space \u2192 exactly periodic in LOOP seconds.\n  // speed = 2\u03C0 * n / LOOP  (n integer \u2192 1 full orbit per loop)\n  float ws = 6.2832 / 12.0;   // 2\u03C0/LOOP \u2014 1 orbit in LOOP s\n  float ws2 = ws * 2.0;       // 2 orbits in LOOP s\n  float warp =\n    vnoise(vec2(cos(angle)*1.4 + sin(uTime*ws )*2.0, sin(angle)*1.4 + cos(uTime*ws )*2.0)) * 0.50 +\n    vnoise(vec2(cos(angle)*2.6 + sin(uTime*ws2)*1.2, sin(angle)*2.6 + cos(uTime*ws2)*1.2)) * 0.25;\n  float organicR = r + (warp - 0.45) * 0.04;\n\n  // Three wave sines \u2014 speeds are 2\u03C0*n/LOOP (n=3,2,1) \u2192 integer cycles in LOOP s.\n  // Spatial frequencies are irrational ratios so they never phase-lock into\n  // distinct bands; the result is one broad, shifting swell.\n  float s1 = 6.2832 * 3.0 / 12.0;  // 3 cycles in LOOP s\n  float s2 = 6.2832 * 2.0 / 12.0;  // 2 cycles\n  float s3 = 6.2832 * 1.0 / 12.0;  // 1 cycle\n  float w =\n    sin(organicR * 4.80 - uTime * s1) * 0.55 +\n    sin(organicR * 2.55 - uTime * s2) * 0.30 +\n    sin(organicR * 1.45 - uTime * s3) * 0.15;\n\n  float phase = w * 0.5 + 0.5;\n  vec3 color = gradientColor(phase);\n\n  float envelope  = smoothstep(0.75, 0.42, r);\n  float centerFill = smoothstep(0.06, 0.0, r);\n  color = mix(color * envelope, gradientColor(0.0), centerFill);\n\n  gl_FragColor = vec4(color, 1.0);\n}\n";
+
+export { FLUID_GRADIENT_LOOP, fragmentShader };
+//# sourceMappingURL=shader.js.map

package/build/lib/web/development/components/Spark/RazorSenseGradient/shader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader.js","sources":["../../../../../../../src/components/Spark/RazorSenseGradient/shader.ts"],"sourcesContent":["export const FLUID_GRADIENT_LOOP = 12.0;\n\n// vec3 c0 = vec3(0.55, 0.95, 0.75);\n// vec3 c1 = vec3(0.35, 0.90, 0.65);\n// vec3 c2 = vec3(0.20, 0.88, 0.70);\n// vec3 c3 = vec3(0.08, 0.82, 0.48);\n// vec3 c4 = vec3(0.04, 0.68, 0.30);\n\n// vec3 c0 = vec3(0.72, 0.92, 1.00); // light sky blue\n// vec3 c1 = vec3(0.38, 0.72, 0.98); // cornflower blue\n// vec3 c2 = vec3(0.16, 0.50, 0.92); // medium blue\n// vec3 c3 = vec3(0.08, 0.30, 0.78); // deep royal blue\n// vec3 c4 = vec3(0.10, 0.28, 0.72); // deep blue (not black)\n\nexport const fragmentShader = /* glsl */ `\nprecision mediump float;\n\nuniform float uTime;    // pre-wrapped: mod(raw, LOOP)\nuniform vec2  iResolution;\nuniform vec2  uOrigin;  // gradient origin in UV space (0,0)=top-left (1,1)=bottom-right\nvarying vec2 vUv;\n\n// Cubic smoothstep inside each segment — no kink at stop boundaries\nvec3 gradientColor(float t) {\n  t = clamp(t, 0.0, 1.0);\n  vec3 c0 = vec3(0.682, 0.957, 0.831);  // 174, 244, 212\n  vec3 c1 = vec3(0.310, 0.882, 0.620);  //  79, 225, 158\n  vec3 c2 = vec3(0.306, 0.973, 0.910);  //  78, 248, 232\n  vec3 c3 = vec3(0.004, 0.753, 0.443);  //   1, 192, 113\n  vec3 c4 = vec3(0.004, 0.753, 0.443);  //   1, 192, 113\n  float s;\n  if (t < 0.25) { s = smoothstep(0.0,1.0, t/0.25);         return mix(c0,c1,s); }\n  if (t < 0.55) { s = smoothstep(0.0,1.0,(t-0.25)/0.30);   return mix(c1,c2,s); }\n  if (t < 0.80) { s = smoothstep(0.0,1.0,(t-0.55)/0.25);   return mix(c2,c3,s); }\n                  s = smoothstep(0.0,1.0,(t-0.80)/0.20);   return mix(c3,c4,s);\n}\n\n// Value noise\nfloat hash(vec2 p) { return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453); }\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p), f = fract(p);\n  vec2 u = f*f*(3.0-2.0*f);\n  return mix(mix(hash(i),hash(i+vec2(1,0)),u.x), mix(hash(i+vec2(0,1)),hash(i+vec2(1,1)),u.x),u.y);\n}\n\nvoid main() {\n  vec2 uv = vUv - uOrigin;\n  float angle = atan(uv.y, uv.x);\n  float r = length(uv);\n\n  // Warp: traces a circle in noise space → exactly periodic in LOOP seconds.\n  // speed = 2π * n / LOOP  (n integer → 1 full orbit per loop)\n  float ws = 6.2832 / 12.0;   // 2π/LOOP — 1 orbit in LOOP s\n  float ws2 = ws * 2.0;       // 2 orbits in LOOP s\n  float warp =\n    vnoise(vec2(cos(angle)*1.4 + sin(uTime*ws )*2.0, sin(angle)*1.4 + cos(uTime*ws )*2.0)) * 0.50 +\n    vnoise(vec2(cos(angle)*2.6 + sin(uTime*ws2)*1.2, sin(angle)*2.6 + cos(uTime*ws2)*1.2)) * 0.25;\n  float organicR = r + (warp - 0.45) * 0.04;\n\n  // Three wave sines — speeds are 2π*n/LOOP (n=3,2,1) → integer cycles in LOOP s.\n  // Spatial frequencies are irrational ratios so they never phase-lock into\n  // distinct bands; the result is one broad, shifting swell.\n  float s1 = 6.2832 * 3.0 / 12.0;  // 3 cycles in LOOP s\n  float s2 = 6.2832 * 2.0 / 12.0;  // 2 cycles\n  float s3 = 6.2832 * 1.0 / 12.0;  // 1 cycle\n  float w =\n    sin(organicR * 4.80 - uTime * s1) * 0.55 +\n    sin(organicR * 2.55 - uTime * s2) * 0.30 +\n    sin(organicR * 1.45 - uTime * s3) * 0.15;\n\n  float phase = w * 0.5 + 0.5;\n  vec3 color = gradientColor(phase);\n\n  float envelope  = smoothstep(0.75, 0.42, r);\n  float centerFill = smoothstep(0.06, 0.0, r);\n  color = mix(color * envelope, gradientColor(0.0), centerFill);\n\n  gl_FragColor = vec4(color, 1.0);\n}\n`;\n"],"names":["FLUID_GRADIENT_LOOP","fragmentShader"],"mappings":"AAAO,IAAMA,mBAAmB,GAAG,KAAI;;AAEvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEO,IAAMC,cAAc,aAiE1B;;;;"}

package/build/lib/web/development/components/Spark/RazorSenseGradient/useFluidGradient.js

@@ -0,0 +1,34 @@
+import { useRef, useEffect } from 'react';
+import { FluidGradientMount } from './FluidGradientMount.js';
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable consistent-return */
+function useFluidGradient(_ref) {
+  var size = _ref.size,
+    _ref$origin = _ref.origin,
+    origin = _ref$origin === void 0 ? [0.5, 0.5] : _ref$origin;
+  var containerRef = useRef(null);
+  var mountRef = useRef(null);
+
+  // Reactively update origin without re-initialising WebGL
+  useEffect(function () {
+    var _mountRef$current;
+    (_mountRef$current = mountRef.current) === null || _mountRef$current === void 0 || _mountRef$current.setOrigin(origin);
+  }, [origin[0], origin[1]]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(function () {
+    var container = containerRef.current;
+    if (!container) return;
+    var mount = new FluidGradientMount(container, size, origin);
+    mountRef.current = mount;
+    return function () {
+      mount.dispose();
+      mountRef.current = null;
+    };
+  }, [size]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  return containerRef;
+}
+
+export { useFluidGradient };
+//# sourceMappingURL=useFluidGradient.js.map

package/build/lib/web/development/components/Spark/RazorSenseGradient/useFluidGradient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFluidGradient.js","sources":["../../../../../../../src/components/Spark/RazorSenseGradient/useFluidGradient.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable consistent-return */\nimport { useEffect, useRef } from 'react';\nimport { FluidGradientMount } from './FluidGradientMount';\n\ninterface UseFluidGradientOptions {\n  size: number;\n  /** Gradient origin in UV space. [0.5, 0.5] = center (default). */\n  origin?: [number, number];\n}\n\nexport function useFluidGradient({ size, origin = [0.5, 0.5] }: UseFluidGradientOptions) {\n  const containerRef = useRef<HTMLDivElement>(null);\n  const mountRef = useRef<FluidGradientMount | null>(null);\n\n  // Reactively update origin without re-initialising WebGL\n  useEffect(() => {\n    mountRef.current?.setOrigin(origin);\n  }, [origin[0], origin[1]]); // eslint-disable-line react-hooks/exhaustive-deps\n\n  useEffect(() => {\n    const container = containerRef.current;\n    if (!container) return;\n\n    const mount = new FluidGradientMount(container, size, origin);\n    mountRef.current = mount;\n\n    return () => {\n      mount.dispose();\n      mountRef.current = null;\n    };\n  }, [size]); // eslint-disable-line react-hooks/exhaustive-deps\n\n  return containerRef;\n}\n"],"names":["useFluidGradient","_ref","size","_ref$origin","origin","containerRef","useRef","mountRef","useEffect","_mountRef$current","current","setOrigin","container","mount","FluidGradientMount","dispose"],"mappings":";;;AAAA;AACA;AAUO,SAASA,gBAAgBA,CAAAC,IAAA,EAAyD;AAAA,EAAA,IAAtDC,IAAI,GAAAD,IAAA,CAAJC,IAAI;IAAAC,WAAA,GAAAF,IAAA,CAAEG,MAAM;IAANA,MAAM,GAAAD,WAAA,KAAG,KAAA,CAAA,GAAA,CAAC,GAAG,EAAE,GAAG,CAAC,GAAAA,WAAA,CAAA;AAC1D,EAAA,IAAME,YAAY,GAAGC,MAAM,CAAiB,IAAI,CAAC,CAAA;AACjD,EAAA,IAAMC,QAAQ,GAAGD,MAAM,CAA4B,IAAI,CAAC,CAAA;;AAExD;AACAE,EAAAA,SAAS,CAAC,YAAM;AAAA,IAAA,IAAAC,iBAAA,CAAA;AACd,IAAA,CAAAA,iBAAA,GAAAF,QAAQ,CAACG,OAAO,MAAA,IAAA,IAAAD,iBAAA,KAAA,KAAA,CAAA,IAAhBA,iBAAA,CAAkBE,SAAS,CAACP,MAAM,CAAC,CAAA;AACrC,GAAC,EAAE,CAACA,MAAM,CAAC,CAAC,CAAC,EAAEA,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;AAE3BI,EAAAA,SAAS,CAAC,YAAM;AACd,IAAA,IAAMI,SAAS,GAAGP,YAAY,CAACK,OAAO,CAAA;IACtC,IAAI,CAACE,SAAS,EAAE,OAAA;IAEhB,IAAMC,KAAK,GAAG,IAAIC,kBAAkB,CAACF,SAAS,EAAEV,IAAI,EAAEE,MAAM,CAAC,CAAA;IAC7DG,QAAQ,CAACG,OAAO,GAAGG,KAAK,CAAA;AAExB,IAAA,OAAO,YAAM;MACXA,KAAK,CAACE,OAAO,EAAE,CAAA;MACfR,QAAQ,CAACG,OAAO,GAAG,IAAI,CAAA;KACxB,CAAA;AACH,GAAC,EAAE,CAACR,IAAI,CAAC,CAAC,CAAC;;AAEX,EAAA,OAAOG,YAAY,CAAA;AACrB;;;;"}

package/build/lib/web/development/components/Spark/RzpGlass/PerformanceManager.js

@@ -0,0 +1,455 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+
+/**
+ * PerformanceManager
+ *
+ * Detects GPU tier and device capability, then produces recommended
+ * RzpGlass render settings. Uses a layered heuristic approach:
+ *
+ *   1. WEBGL_debug_renderer_info  – parse GPU renderer/vendor strings
+ *   2. failIfMajorPerformanceCaveat  – fast browser-level GPU check
+ *   3. Device signals  – deviceMemory, hardwareConcurrency, mobile UA
+ *
+ * Tier definitions:
+ *   high   – discrete / flagship mobile GPU, ample memory
+ *   mid    – integrated / mid-range mobile GPU
+ *   low    – software renderer, very old GPU, or constrained device
+ *   unknown – could not determine (treated as mid for safety)
+ */
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Known renderer pattern lists
+// ---------------------------------------------------------------------------
+
+/**
+ * Patterns that indicate a software / CPU renderer (potato tier).
+ * These devices cannot run WebGL at any usable framerate.
+ */
+var POTATO_TIER_PATTERNS = [/swiftshader/, /llvmpipe/, /softpipe/, /microsoft basic render/, /virgl/];
+
+/**
+ * Patterns that strongly indicate a low-end GPU.
+ * Tested against the lowercased GL_RENDERER string.
+ */
+var LOW_TIER_PATTERNS = [
+// Old Intel integrated
+/intel.*hd\s*(graphics)?\s*(2000|3000|4000|400|500|510|520|530)/, /intel.*gma/,
+// Old AMD integrated
+/amd.*radeon.*r[2-5]\s/, /amd.*radeon.*hd\s*(6|7)\d{3}/,
+// Very old NVIDIA
+/nvidia.*geforce\s*(4|5|6|7|8|9)\d{2}[^0]/,
+// Old mobile GPUs
+/mali-(4|t[0-9]|g5[0-7])\d*/, /adreno\s*(3|4)\d{2}/, /powervr.*sgx/, /vivante/, /gc\d{3}[^0-9]/ // Vivante GC series
+];
+
+/**
+ * Patterns that indicate a high-end GPU.
+ */
+var HIGH_TIER_PATTERNS = [
+// NVIDIA discrete
+/nvidia.*rtx/, /nvidia.*gtx\s*1[0-9]{3}/, /nvidia.*gtx\s*[2-9]\d{3}/, /nvidia.*quadro/, /nvidia.*titan/,
+// AMD discrete
+/amd.*rx\s*(5|6|7)\d{3}/, /amd.*radeon\s*(pro|rx)\s*(vega|5|6|7)/, /radeon\s*r9/,
+// Apple Silicon
+/apple\s*(m[1-9]|a1[5-9]|a[2-9]\d)/,
+// Modern mobile flagship
+/adreno\s*(7[3-9]\d|8\d{2})/, /mali-g(7[1-9]|[89]\d|[1-9]\d{2})/, /gpu\s*family\s*(apple\s*[5-9]|apple\s*[1-9]\d)/];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isMobileDevice() {
+  return /android|iphone|ipad|ipod|mobile/i.test(navigator.userAgent);
+}
+function getDeviceMemoryGB() {
+  var mem = navigator.deviceMemory;
+  return mem != null ? mem : null;
+}
+function getCpuCores() {
+  var _navigator$hardwareCo;
+  return (_navigator$hardwareCo = navigator.hardwareConcurrency) !== null && _navigator$hardwareCo !== void 0 ? _navigator$hardwareCo : 2;
+}
+
+/**
+ * Probes the WEBGL_debug_renderer_info extension to get raw GPU strings.
+ * Returns nulls if the extension is unavailable or blocked (privacy protection).
+ */
+function getGpuStrings(gl) {
+  var ext = gl.getExtension('WEBGL_debug_renderer_info');
+  if (!ext) return {
+    renderer: null,
+    vendor: null
+  };
+  var renderer = gl.getParameter(ext.UNMASKED_RENDERER_WEBGL);
+  var vendor = gl.getParameter(ext.UNMASKED_VENDOR_WEBGL);
+  return {
+    renderer: renderer,
+    vendor: vendor
+  };
+}
+
+/**
+ * Checks whether the browser signals a major performance caveat (software/swiftshader).
+ */
+function checkMajorPerformanceCaveat() {
+  var canvas = document.createElement('canvas');
+  var gl = canvas.getContext('webgl', {
+    failIfMajorPerformanceCaveat: true
+  });
+  return gl === null;
+}
+
+/**
+ * Classify a GPU into a tier using the renderer / vendor strings.
+ * Returns null if classification is inconclusive.
+ */
+function classifyByRendererString(renderer, vendor) {
+  if (!renderer && !vendor) return null;
+  var combined = "".concat(renderer !== null && renderer !== void 0 ? renderer : '', " ").concat(vendor !== null && vendor !== void 0 ? vendor : '').toLowerCase();
+  for (var _i = 0, _POTATO_TIER_PATTERNS = POTATO_TIER_PATTERNS; _i < _POTATO_TIER_PATTERNS.length; _i++) {
+    var pattern = _POTATO_TIER_PATTERNS[_i];
+    if (pattern.test(combined)) return 'potato';
+  }
+  for (var _i2 = 0, _LOW_TIER_PATTERNS = LOW_TIER_PATTERNS; _i2 < _LOW_TIER_PATTERNS.length; _i2++) {
+    var _pattern = _LOW_TIER_PATTERNS[_i2];
+    if (_pattern.test(combined)) return 'low';
+  }
+  for (var _i3 = 0, _HIGH_TIER_PATTERNS = HIGH_TIER_PATTERNS; _i3 < _HIGH_TIER_PATTERNS.length; _i3++) {
+    var _pattern2 = _HIGH_TIER_PATTERNS[_i3];
+    if (_pattern2.test(combined)) return 'high';
+  }
+  return null; // inconclusive – fall through to device signals
+}
+
+/**
+ * Derive a tier purely from device-level signals (no GPU string needed).
+ */
+function classifyByDeviceSignals(memoryGB, cores, mobile) {
+  // Very constrained device
+  if (memoryGB !== null && memoryGB <= 2) return 'low';
+  if (cores <= 2) return 'low';
+
+  // Well-resourced device
+  if (memoryGB !== null && memoryGB >= 8 && cores >= 8 && !mobile) return 'high';
+  if (memoryGB !== null && memoryGB >= 6 && cores >= 6) return 'high';
+  return 'mid';
+}
+
+// ---------------------------------------------------------------------------
+// Per-tier render settings
+// ---------------------------------------------------------------------------
+
+var RENDER_SETTINGS = {
+  high: {
+    // ~4K equivalent
+    maxPixelCount: 1920 * 1080 * 4,
+    minPixelRatio: 2
+  },
+  mid: {
+    // ~1080p equivalent
+    maxPixelCount: 1920 * 1080 * 2,
+    minPixelRatio: 1
+  },
+  low: {
+    // ~720p max
+    maxPixelCount: 1280 * 720,
+    minPixelRatio: 1
+  },
+  potato: {
+    // Software renderer – show static fallback immediately
+    maxPixelCount: 0,
+    minPixelRatio: 1
+  },
+  unknown: {
+    // Treat conservatively – same as mid
+    maxPixelCount: 1920 * 1080 * 2,
+    minPixelRatio: 1
+  }
+};
+
+/**
+ * Maps PerformanceLevel → RenderSettings so callers can apply the right
+ * pixel budget when the level changes. Reuses RENDER_SETTINGS values so the
+ * two tables stay in sync.
+ *
+ *   3 (full)     → high  tier settings
+ *   2 (stable)   → mid   tier settings
+ *   1 (degraded) → low   tier settings
+ *   0 (fallback) → low   tier settings (canvas will be hidden anyway)
+ */
+var LEVEL_RENDER_SETTINGS = {
+  3: RENDER_SETTINGS.high,
+  2: RENDER_SETTINGS.mid,
+  1: RENDER_SETTINGS.low,
+  0: RENDER_SETTINGS.low
+};
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds a PerformanceProfile by inspecting the provided WebGL context and
+ * available browser / navigator APIs. No async work is performed.
+ *
+ * @example
+ * ```ts
+ * const profile = PerformanceManager.detect(gl);
+ * console.log(profile.tier);          // 'high' | 'mid' | 'low' | 'unknown'
+ *
+ * const mount = new RzpGlassMount(
+ *   el,
+ *   assets,
+ *   {},
+ *   0,
+ *   profile.renderSettings.minPixelRatio,
+ *   profile.renderSettings.maxPixelCount,
+ * );
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+var PerformanceManager = /*#__PURE__*/function () {
+  function PerformanceManager() {
+    _classCallCheck(this, PerformanceManager);
+  }
+  return _createClass(PerformanceManager, null, [{
+    key: "detect",
+    value:
+    /**
+     * Detect GPU tier and return a full PerformanceProfile.
+     *
+     * @param gl - An existing WebGLRenderingContext (e.g. from RzpGlassMount).
+     *             If not provided, a temporary offscreen context is created.
+     */
+    function detect(gl) {
+      var ownedCanvas = false;
+      var ctx = gl !== null && gl !== void 0 ? gl : null;
+      if (!ctx) {
+        var _canvas$getContext;
+        var canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = 1;
+        ctx = (_canvas$getContext = canvas.getContext('webgl')) !== null && _canvas$getContext !== void 0 ? _canvas$getContext : null;
+        ownedCanvas = true;
+      }
+      var mobile = isMobileDevice();
+      var memoryGB = getDeviceMemoryGB();
+      var cores = getCpuCores();
+      var hasMajorPerformanceCaveat = checkMajorPerformanceCaveat();
+      var gpuRenderer = null;
+      var gpuVendor = null;
+      if (ctx) {
+        var _getGpuStrings = getGpuStrings(ctx),
+          renderer = _getGpuStrings.renderer,
+          vendor = _getGpuStrings.vendor;
+        gpuRenderer = renderer;
+        gpuVendor = vendor;
+        if (ownedCanvas) {
+          // Let the browser GC the temp context – no explicit destroy needed
+          ctx = null;
+        }
+      }
+
+      // Immediate potato-tier signal from caveat check (software renderer)
+      var tier;
+      if (hasMajorPerformanceCaveat) {
+        tier = 'potato';
+      } else {
+        var _classifyByRendererSt;
+        tier = (_classifyByRendererSt = classifyByRendererString(gpuRenderer, gpuVendor)) !== null && _classifyByRendererSt !== void 0 ? _classifyByRendererSt : classifyByDeviceSignals(memoryGB, cores, mobile);
+      }
+
+      // Downgrade high → mid on mobile (thermal / power constraints)
+      if (tier === 'high' && mobile) {
+        tier = 'mid';
+      }
+      return {
+        tier: tier,
+        gpuRenderer: gpuRenderer,
+        gpuVendor: gpuVendor,
+        deviceMemory: memoryGB,
+        hardwareConcurrency: cores,
+        isMobile: mobile,
+        hasMajorPerformanceCaveat: hasMajorPerformanceCaveat,
+        renderSettings: RENDER_SETTINGS[tier]
+      };
+    }
+
+    /**
+     * Convenience: returns only the recommended RenderSettings without the
+     * full diagnostic data.
+     */
+  }, {
+    key: "getRenderSettings",
+    value: function getRenderSettings(gl) {
+      return PerformanceManager.detect(gl).renderSettings;
+    }
+  }]);
+}(); // ---------------------------------------------------------------------------
+// WebGLPerformanceController
+// ---------------------------------------------------------------------------
+/** Performance level: 3 = full quality, 0 = static fallback */
+var TIER_INITIAL_STATE = {
+  high: 3,
+  mid: 2,
+  low: 1,
+  potato: 0,
+  unknown: 2
+};
+
+/**
+ * Monitors real-time FPS and fires onLevelChange when quality should be adjusted.
+ * Initial level is seeded from the GPU tier detected by PerformanceManager.
+ *
+ * Level semantics:
+ *   3 – full quality
+ *   2 – stable
+ *   1 – degraded
+ *   0 – static fallback (onLevelChange(0) fired)
+ *
+ * @example
+ * ```ts
+ * const controller = new WebGLPerformanceController({
+ *   canvas,
+ *   gl,
+ *   onLevelChange: (level) => {
+ *     if (level === 0) showStaticFallback();
+ *   },
+ * });
+ *
+ * // When done:
+ * controller.dispose();
+ * ```
+ */
+var WebGLPerformanceController = /*#__PURE__*/function () {
+  function WebGLPerformanceController(_ref) {
+    var _this = this;
+    var gl = _ref.gl,
+      _ref$onLevelChange = _ref.onLevelChange,
+      onLevelChange = _ref$onLevelChange === void 0 ? null : _ref$onLevelChange;
+    _classCallCheck(this, WebGLPerformanceController);
+    _defineProperty(this, "cooldown", 3000);
+    _defineProperty(this, "lastChange", 0);
+    _defineProperty(this, "frameCount", 0);
+    _defineProperty(this, "lastTime", performance.now());
+    _defineProperty(this, "fps", 60);
+    _defineProperty(this, "rafId", null);
+    _defineProperty(this, "disposed", false);
+    _defineProperty(this, "handleVisibilityChange", function () {
+      if (document.hidden) {
+        // Pause the monitoring loop — RAF is throttled while hidden and would
+        // produce artificially low FPS readings that trigger false fallbacks.
+        if (_this.rafId !== null) {
+          cancelAnimationFrame(_this.rafId);
+          _this.rafId = null;
+        }
+      } else {
+        // Reset FPS state so the stale hidden-period sample is discarded,
+        // then resume monitoring from a clean baseline.
+        _this.frameCount = 0;
+        _this.lastTime = performance.now();
+        _this.fps = 60;
+        _this.startMonitoring();
+      }
+    });
+    this.onLevelChange = onLevelChange;
+    var _PerformanceManager$d = PerformanceManager.detect(gl),
+      tier = _PerformanceManager$d.tier;
+    this.level = TIER_INITIAL_STATE[tier];
+    if (this.level === 0) {
+      this.forceStaticFallback();
+      return;
+    }
+    onLevelChange === null || onLevelChange === void 0 || onLevelChange(this.level);
+    this.startMonitoring();
+    document.addEventListener('visibilitychange', this.handleVisibilityChange);
+  }
+  return _createClass(WebGLPerformanceController, [{
+    key: "setLevel",
+    value: function setLevel(level) {
+      var _this$onLevelChange;
+      if (this.level === level) return;
+      var now = performance.now();
+      if (now - this.lastChange < this.cooldown) return;
+      this.level = level;
+      this.lastChange = now;
+      if (level === 0) {
+        this.forceStaticFallback();
+        return;
+      }
+      (_this$onLevelChange = this.onLevelChange) === null || _this$onLevelChange === void 0 || _this$onLevelChange.call(this, level);
+    }
+  }, {
+    key: "forceStaticFallback",
+    value: function forceStaticFallback() {
+      var _this$onLevelChange2;
+      this.level = 0;
+      (_this$onLevelChange2 = this.onLevelChange) === null || _this$onLevelChange2 === void 0 || _this$onLevelChange2.call(this, 0);
+    }
+  }, {
+    key: "evaluatePerformance",
+    value: function evaluatePerformance() {
+      if (this.fps < 20) {
+        this.setLevel(0);
+      } else if (this.fps < 40) {
+        this.setLevel(1);
+      } else if (this.fps < 55) {
+        this.setLevel(2);
+      } else {
+        this.setLevel(3);
+      }
+    }
+  }, {
+    key: "startMonitoring",
+    value: function startMonitoring() {
+      var _this2 = this;
+      var _loop = function loop() {
+        if (_this2.disposed) return;
+        var now = performance.now();
+        _this2.frameCount++;
+        if (now - _this2.lastTime >= 1000) {
+          _this2.fps = _this2.frameCount;
+          _this2.frameCount = 0;
+          _this2.lastTime = now;
+          _this2.evaluatePerformance();
+        }
+        _this2.rafId = requestAnimationFrame(_loop);
+      };
+      this.rafId = requestAnimationFrame(_loop);
+    }
+  }, {
+    key: "isPotato",
+    value: function isPotato() {
+      return this.level === 0;
+    }
+
+    /** Current performance level (3 = full, 0 = fallback) */
+  }, {
+    key: "getLevel",
+    value: function getLevel() {
+      return this.level;
+    }
+
+    /** Stop the monitoring loop and release resources */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.disposed = true;
+      if (this.rafId !== null) {
+        cancelAnimationFrame(this.rafId);
+        this.rafId = null;
+      }
+      document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+    }
+  }]);
+}();
+
+export { LEVEL_RENDER_SETTINGS, RENDER_SETTINGS, WebGLPerformanceController };
+//# sourceMappingURL=PerformanceManager.js.map