@luma.gl/webgl 9.0.0-alpha.14 → 9.0.0-alpha.16

package/dist/es5/classic/typed-array-utils.js

@@ -1,97 +1,73 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.flipRows = flipRows;
 exports.getGLTypeFromTypedArray = getGLTypeFromTypedArray;
 exports.getTypedArrayFromGLType = getTypedArrayFromGLType;
-exports.flipRows = flipRows;
 exports.scalePixels = scalePixels;
-
 var _constants = _interopRequireDefault(require("@luma.gl/constants"));
-
 var ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
-
 function getGLTypeFromTypedArray(arrayOrType) {
   var type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-
   switch (type) {
     case Float32Array:
       return _constants.default.FLOAT;
-
     case Uint16Array:
       return _constants.default.UNSIGNED_SHORT;
-
     case Uint32Array:
       return _constants.default.UNSIGNED_INT;
-
     case Uint8Array:
       return _constants.default.UNSIGNED_BYTE;
-
     case Uint8ClampedArray:
       return _constants.default.UNSIGNED_BYTE;
-
     case Int8Array:
       return _constants.default.BYTE;
-
     case Int16Array:
       return _constants.default.SHORT;
-
     case Int32Array:
       return _constants.default.INT;
-
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
 }
-
 function getTypedArrayFromGLType(glType, options) {
   var _ref = options || {},
-      _ref$clamped = _ref.clamped,
-      clamped = _ref$clamped === void 0 ? true : _ref$clamped;
-
+    _ref$clamped = _ref.clamped,
+    clamped = _ref$clamped === void 0 ? true : _ref$clamped;
   switch (glType) {
     case _constants.default.FLOAT:
       return Float32Array;
-
     case _constants.default.UNSIGNED_SHORT:
     case _constants.default.UNSIGNED_SHORT_5_6_5:
     case _constants.default.UNSIGNED_SHORT_4_4_4_4:
     case _constants.default.UNSIGNED_SHORT_5_5_5_1:
       return Uint16Array;
-
     case _constants.default.UNSIGNED_INT:
       return Uint32Array;
-
     case _constants.default.UNSIGNED_BYTE:
       return clamped ? Uint8ClampedArray : Uint8Array;
-
     case _constants.default.BYTE:
       return Int8Array;
-
     case _constants.default.SHORT:
       return Int16Array;
-
     case _constants.default.INT:
       return Int32Array;
-
     default:
       throw new Error('Failed to deduce typed array type from GL constant');
   }
 }
-
 function flipRows(options) {
   var data = options.data,
-      width = options.width,
-      height = options.height,
-      _options$bytesPerPixe = options.bytesPerPixel,
-      bytesPerPixel = _options$bytesPerPixe === void 0 ? 4 : _options$bytesPerPixe,
-      temp = options.temp;
+    width = options.width,
+    height = options.height,
+    _options$bytesPerPixe = options.bytesPerPixel,
+    bytesPerPixel = _options$bytesPerPixe === void 0 ? 4 : _options$bytesPerPixe,
+    temp = options.temp;
   var bytesPerRow = width * bytesPerPixel;
   var tempBuffer = temp || new Uint8Array(bytesPerRow);
-
   for (var y = 0; y < height / 2; ++y) {
     var topOffset = y * bytesPerRow;
     var bottomOffset = (height - y - 1) * bytesPerRow;
@@ -100,15 +76,13 @@ function flipRows(options) {
     data.set(tempBuffer, bottomOffset);
   }
 }
-
 function scalePixels(options) {
   var data = options.data,
-      width = options.width,
-      height = options.height;
+    width = options.width,
+    height = options.height;
   var newWidth = Math.round(width / 2);
   var newHeight = Math.round(height / 2);
   var newData = new Uint8Array(newWidth * newHeight * 4);
-
   for (var y = 0; y < newHeight; y++) {
     for (var x = 0; x < newWidth; x++) {
       for (var c = 0; c < 4; c++) {
@@ -116,7 +90,6 @@ function scalePixels(options) {
       }
     }
   }
-
   return {
     data: newData,
     width: newWidth,

package/dist/es5/classic/typed-array-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/classic/typed-array-utils.ts"],"names":["ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","GL","FLOAT","Uint16Array","UNSIGNED_SHORT","Uint32Array","UNSIGNED_INT","Uint8Array","UNSIGNED_BYTE","Uint8ClampedArray","Int8Array","BYTE","Int16Array","SHORT","Int32Array","INT","Error","getTypedArrayFromGLType","glType","options","clamped","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","flipRows","data","width","height","bytesPerPixel","temp","bytesPerRow","tempBuffer","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\n\nimport {TypedArray} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {GLType} from '../types/webgl'\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\ntype TypedArrayConstructor =\n  | Float32ArrayConstructor\n  | Uint16ArrayConstructor\n  | Uint32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Uint8ClampedArrayConstructor\n  | Int8ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor;\n\n/**\n * Converts TYPED ARRAYS to corresponding GL constant\n * Used to auto deduce gl parameter types\n * @param {*} arrayOrType\n * @returns\n */\nexport function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n/**\n * Converts GL constant to corresponding TYPED ARRAY\n * Used to auto deduce gl parameter types\n * @param {*} glType\n * @param {*} param1\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayFromGLType(\n  glType: any,\n  options?: {\n    clamped?: boolean;\n  }\n): TypedArrayConstructor {\n  const {clamped = true} = options || {};\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n\n/**\n * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n * https: *stackoverflow.com/questions/41969562/\n * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\n * @param {*} param0\n */\n export function flipRows(options: {\n  data: any;\n  width: any;\n  height: any;\n  bytesPerPixel?: number;\n  temp?: any;\n}): void {\n  const {data, width, height, bytesPerPixel = 4, temp} = options;\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  const tempBuffer = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(tempBuffer, bottomOffset);\n  }\n}\n\n\nexport function scalePixels(options: {\n  data: any;\n  width: any;\n  height: any;\n}): {\n  data: Uint8Array;\n  width: number;\n  height: number;\n} {\n  const {data, width, height} = options;\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n"],"file":"typed-array-utils.js"}
+{"version":3,"file":"typed-array-utils.js","names":["_constants","_interopRequireDefault","require","ERR_TYPE_DEDUCTION","getGLTypeFromTypedArray","arrayOrType","type","ArrayBuffer","isView","constructor","Float32Array","GL","FLOAT","Uint16Array","UNSIGNED_SHORT","Uint32Array","UNSIGNED_INT","Uint8Array","UNSIGNED_BYTE","Uint8ClampedArray","Int8Array","BYTE","Int16Array","SHORT","Int32Array","INT","Error","getTypedArrayFromGLType","glType","options","_ref","_ref$clamped","clamped","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","flipRows","data","width","height","_options$bytesPerPixe","bytesPerPixel","temp","bytesPerRow","tempBuffer","y","topOffset","bottomOffset","set","subarray","copyWithin","scalePixels","newWidth","Math","round","newHeight","newData","x","c"],"sources":["../../../src/classic/typed-array-utils.ts"],"sourcesContent":["// luma.gl, MIT license\n\nimport {TypedArray} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {GLType} from '../types/webgl'\n\nconst ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';\n\ntype TypedArrayConstructor =\n  | Float32ArrayConstructor\n  | Uint16ArrayConstructor\n  | Uint32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Uint8ClampedArrayConstructor\n  | Int8ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor;\n\n/**\n * Converts TYPED ARRAYS to corresponding GL constant\n * Used to auto deduce gl parameter types\n * @param {*} arrayOrType\n * @returns\n */\nexport function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLType {\n  // If typed array, look up constructor\n  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n  switch (type) {\n    case Float32Array:\n      return GL.FLOAT;\n    case Uint16Array:\n      return GL.UNSIGNED_SHORT;\n    case Uint32Array:\n      return GL.UNSIGNED_INT;\n    case Uint8Array:\n      return GL.UNSIGNED_BYTE;\n    case Uint8ClampedArray:\n      return GL.UNSIGNED_BYTE;\n    case Int8Array:\n      return GL.BYTE;\n    case Int16Array:\n      return GL.SHORT;\n    case Int32Array:\n      return GL.INT;\n    default:\n      throw new Error(ERR_TYPE_DEDUCTION);\n  }\n}\n\n/**\n * Converts GL constant to corresponding TYPED ARRAY\n * Used to auto deduce gl parameter types\n * @param {*} glType\n * @param {*} param1\n * @returns\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayFromGLType(\n  glType: any,\n  options?: {\n    clamped?: boolean;\n  }\n): TypedArrayConstructor {\n  const {clamped = true} = options || {};\n  // Sorted in some order of likelihood to reduce amount of comparisons\n  switch (glType) {\n    case GL.FLOAT:\n      return Float32Array;\n    case GL.UNSIGNED_SHORT:\n    case GL.UNSIGNED_SHORT_5_6_5:\n    case GL.UNSIGNED_SHORT_4_4_4_4:\n    case GL.UNSIGNED_SHORT_5_5_5_1:\n      return Uint16Array;\n    case GL.UNSIGNED_INT:\n      return Uint32Array;\n    case GL.UNSIGNED_BYTE:\n      return clamped ? Uint8ClampedArray : Uint8Array;\n    case GL.BYTE:\n      return Int8Array;\n    case GL.SHORT:\n      return Int16Array;\n    case GL.INT:\n      return Int32Array;\n    default:\n      throw new Error('Failed to deduce typed array type from GL constant');\n  }\n}\n\n/**\n * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)\n * https: *stackoverflow.com/questions/41969562/\n * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels\n * @param {*} param0\n */\n export function flipRows(options: {\n  data: any;\n  width: any;\n  height: any;\n  bytesPerPixel?: number;\n  temp?: any;\n}): void {\n  const {data, width, height, bytesPerPixel = 4, temp} = options;\n  const bytesPerRow = width * bytesPerPixel;\n\n  // make a temp buffer to hold one row\n  const tempBuffer = temp || new Uint8Array(bytesPerRow);\n  for (let y = 0; y < height / 2; ++y) {\n    const topOffset = y * bytesPerRow;\n    const bottomOffset = (height - y - 1) * bytesPerRow;\n    // make copy of a row on the top half\n    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));\n    // copy a row from the bottom half to the top\n    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);\n    // copy the copy of the top half row to the bottom half\n    data.set(tempBuffer, bottomOffset);\n  }\n}\n\n\nexport function scalePixels(options: {\n  data: any;\n  width: any;\n  height: any;\n}): {\n  data: Uint8Array;\n  width: number;\n  height: number;\n} {\n  const {data, width, height} = options;\n  const newWidth = Math.round(width / 2);\n  const newHeight = Math.round(height / 2);\n  const newData = new Uint8Array(newWidth * newHeight * 4);\n  for (let y = 0; y < newHeight; y++) {\n    for (let x = 0; x < newWidth; x++) {\n      for (let c = 0; c < 4; c++) {\n        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];\n      }\n    }\n  }\n  return {data: newData, width: newWidth, height: newHeight};\n}\n"],"mappings":"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"}

package/dist/es5/context/context/create-browser-context.js

@@ -1,18 +1,13 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createBrowserContext = createBrowserContext;
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var DEFAULT_CONTEXT_PROPS = {
   webgl2: true,
   webgl1: true,
@@ -24,60 +19,48 @@ var DEFAULT_CONTEXT_PROPS = {
     return console.info('WebGL context restored');
   }
 };
-
 function createBrowserContext(canvas, props) {
   props = _objectSpread(_objectSpread({}, DEFAULT_CONTEXT_PROPS), props);
   var errorMessage = null;
-
   var onCreateError = function onCreateError(error) {
     return errorMessage = error.statusMessage || errorMessage;
   };
-
   canvas.addEventListener('webglcontextcreationerror', onCreateError, false);
   var gl = null;
-
   if (props.type === 'webgl2') {
     props = _objectSpread(_objectSpread({}, props), {}, {
       webgl1: false
     });
   }
-
   if (props.type === 'webgl1') {
     props = _objectSpread(_objectSpread({}, props), {}, {
       webgl2: false
     });
   }
-
   if (props.webgl2) {
     gl = gl || canvas.getContext('webgl2', props);
   }
-
   if (props.webgl1) {
     gl = gl || canvas.getContext('webgl', props);
   }
-
   canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);
-
   if (!gl) {
     throw new Error("Failed to create ".concat(props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL', " context: ").concat(errorMessage || 'Unknown error'));
   }
-
   if (props.onContextLost) {
     var _props = props,
-        onContextLost = _props.onContextLost;
+      onContextLost = _props.onContextLost;
     canvas.addEventListener('webglcontextlost', function (event) {
       return onContextLost(event);
     }, false);
   }
-
   if (props.onContextRestored) {
     var _props2 = props,
-        onContextRestored = _props2.onContextRestored;
+      onContextRestored = _props2.onContextRestored;
     canvas.addEventListener('webglcontextrestored', function (event) {
       return onContextRestored(event);
     }, false);
   }
-
   return gl;
 }
 //# sourceMappingURL=create-browser-context.js.map

package/dist/es5/context/context/create-browser-context.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/context/context/create-browser-context.ts"],"names":["DEFAULT_CONTEXT_PROPS","webgl2","webgl1","powerPreference","onContextLost","console","error","onContextRestored","info","createBrowserContext","canvas","props","errorMessage","onCreateError","statusMessage","addEventListener","gl","type","getContext","removeEventListener","Error","event"],"mappings":";;;;;;;;;;;;;;;AAmCA,IAAMA,qBAAmC,GAAG;AAC1CC,EAAAA,MAAM,EAAE,IADkC;AAE1CC,EAAAA,MAAM,EAAE,IAFkC;AAG1CC,EAAAA,eAAe,EAAE,kBAHyB;AAI1CC,EAAAA,aAAa,EAAE;AAAA,WAAMC,OAAO,CAACC,KAAR,CAAc,oBAAd,CAAN;AAAA,GAJ2B;AAK1CC,EAAAA,iBAAiB,EAAE;AAAA,WAAMF,OAAO,CAACG,IAAR,CAAa,wBAAb,CAAN;AAAA;AALuB,CAA5C;;AAaQ,SAASC,oBAAT,CAA8BC,MAA9B,EAA2EC,KAA3E,EAAuH;AAC5HA,EAAAA,KAAK,mCAAOX,qBAAP,GAAiCW,KAAjC,CAAL;AAGD,MAAIC,YAAY,GAAG,IAAnB;;AACA,MAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAACP,KAAD;AAAA,WAAYM,YAAY,GAAGN,KAAK,CAACQ,aAAN,IAAuBF,YAAlD;AAAA,GAAtB;;AACAF,EAAAA,MAAM,CAACK,gBAAP,CAAwB,2BAAxB,EAAqDF,aAArD,EAAoE,KAApE;AAGA,MAAIG,EAAgC,GAAG,IAAvC;;AAEA,MAAIL,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,mCAAOA,KAAP;AAAcT,MAAAA,MAAM,EAAE;AAAtB,MAAL;AACD;;AACD,MAAIS,KAAK,CAACM,IAAN,KAAe,QAAnB,EAA6B;AAC3BN,IAAAA,KAAK,mCAAOA,KAAP;AAAcV,MAAAA,MAAM,EAAE;AAAtB,MAAL;AACD;;AAGD,MAAIU,KAAK,CAACV,MAAV,EAAkB;AAChBe,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,QAAlB,EAA4BP,KAA5B,CAAX;AACD;;AACD,MAAIA,KAAK,CAACT,MAAV,EAAkB;AAChBc,IAAAA,EAAE,GAAGA,EAAE,IAAIN,MAAM,CAACQ,UAAP,CAAkB,OAAlB,EAA2BP,KAA3B,CAAX;AACD;;AAGDD,EAAAA,MAAM,CAACS,mBAAP,CAA2B,2BAA3B,EAAwDN,aAAxD,EAAuE,KAAvE;;AAEA,MAAI,CAACG,EAAL,EAAS;AACP,UAAM,IAAII,KAAJ,4BACgBT,KAAK,CAACV,MAAN,IAAgB,CAACU,KAAK,CAACT,MAAvB,GAAgC,QAAhC,GAA2C,OAD3D,uBAEFU,YAAY,IAAI,eAFd,EAAN;AAKD;;AAED,MAAID,KAAK,CAACP,aAAV,EAAyB;AAEvB,iBAAwBO,KAAxB;AAAA,QAAOP,aAAP,UAAOA,aAAP;AACAM,IAAAA,MAAM,CAACK,gBAAP,CAAwB,kBAAxB,EAA2C,UAACM,KAAD;AAAA,aAAkBjB,aAAa,CAACiB,KAAD,CAA/B;AAAA,KAA3C,EAAmF,KAAnF;AACD;;AACD,MAAIV,KAAK,CAACJ,iBAAV,EAA6B;AAE3B,kBAA4BI,KAA5B;AAAA,QAAOJ,iBAAP,WAAOA,iBAAP;AACAG,IAAAA,MAAM,CAACK,gBAAP,CAAwB,sBAAxB,EAAgD,UAACM,KAAD;AAAA,aAAkBd,iBAAiB,CAACc,KAAD,CAAnC;AAAA,KAAhD,EAA4F,KAA5F;AACD;;AAED,SAAOL,EAAP;AACD","sourcesContent":["// luma.gl, MIT license\n\n/**\n * ContextProps\n* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)\n* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)\n* @param onContextLost\n* @param onContextRestored\n*\n* BROWSER CONTEXT PARAMETERS\n* @param debug Instrument context (at the expense of performance).\n* @param alpha Default render target has an alpha buffer.\n* @param depth Default render target has a depth buffer of at least 16 bits.\n* @param stencil Default render target has a stencil buffer of at least 8 bits.\n* @param antialias Boolean that indicates whether or not to perform anti-aliasing.\n* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.\n*/\ntype ContextProps = {\n  type?: 'webgl' | 'webgl1' | 'webgl2' | string;\n  webgl1?: boolean;\n  webgl2?: boolean;\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  alpha?: boolean; // indicates if the canvas contains an alpha buffer.\n  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop\n  antialias?: boolean; // indicates whether or not to perform anti-aliasing.\n  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.\n  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.\n  powerPreference?: 'default' |  'high-performance' | 'low-power',\n  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.\n};\n\nconst DEFAULT_CONTEXT_PROPS: ContextProps = {\n  webgl2: true, // Attempt to create a WebGL2 context\n  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)\n  powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n};\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n* @param canvas A canvas element or offscreen canvas\n */\n export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {\n   props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  // Create the desired context\n  let gl: WebGLRenderingContext | null = null;\n\n  if (props.type === 'webgl2') {\n    props = {...props, webgl1: false};\n  }\n  if (props.type === 'webgl1') {\n    props = {...props, webgl2: false};\n  }\n\n  // Prefer webgl2 over webgl1 if both are acceptable\n  if (props.webgl2) {\n    gl = gl || canvas.getContext('webgl2', props) as WebGL2RenderingContext | null;\n  }\n  if (props.webgl1) {\n    gl = gl || canvas.getContext('webgl', props) as WebGLRenderingContext | null;\n  }\n\n  // TODO are we removing this listener before giving it a chance to fire?\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    throw new Error(\n      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${\n        errorMessage || 'Unknown error'\n      }`\n    );\n  }\n\n  if (props.onContextLost) {\n    // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.\n    const {onContextLost} = props;\n    canvas.addEventListener('webglcontextlost',(event: Event) => onContextLost(event), false);\n  }\n  if (props.onContextRestored) {\n    // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.\n    const {onContextRestored} = props;\n    canvas.addEventListener('webglcontextrestored', (event: Event) => onContextRestored(event), false);\n  }\n\n  return gl;\n}\n\n/* TODO - can we call this asynchronously to catch the error events?\nexport async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {\n  props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n // Try to extract any extra information about why context creation failed\n let errorMessage = null;\n const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n const gl = createBrowserContext(canvas, props);\n\n // Give the listener a chance to fire\n await new Promise(resolve => setTimeout(resolve, 0));\n\n canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n return gl;\n}\n*/\n"],"file":"create-browser-context.js"}
+{"version":3,"file":"create-browser-context.js","names":["DEFAULT_CONTEXT_PROPS","webgl2","webgl1","powerPreference","onContextLost","console","error","onContextRestored","info","createBrowserContext","canvas","props","_objectSpread","errorMessage","onCreateError","statusMessage","addEventListener","gl","type","getContext","removeEventListener","Error","concat","_props","event","_props2"],"sources":["../../../../src/context/context/create-browser-context.ts"],"sourcesContent":["// luma.gl, MIT license\n\n/**\n * ContextProps\n* @param webgl2 Set to false to not create a WebGL2 context (force webgl1)\n* @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)\n* @param onContextLost\n* @param onContextRestored\n*\n* BROWSER CONTEXT PARAMETERS\n* @param debug Instrument context (at the expense of performance).\n* @param alpha Default render target has an alpha buffer.\n* @param depth Default render target has a depth buffer of at least 16 bits.\n* @param stencil Default render target has a stencil buffer of at least 8 bits.\n* @param antialias Boolean that indicates whether or not to perform anti-aliasing.\n* @param premultipliedAlpha Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n* @param preserveDrawingBuffer Default render target buffers will not be automatically cleared and will preserve their values until cleared or overwritten\n* @param failIfMajorPerformanceCaveat Do not create if the system performance is low.\n*/\ntype ContextProps = {\n  type?: 'webgl' | 'webgl1' | 'webgl2' | string;\n  webgl1?: boolean;\n  webgl2?: boolean;\n  onContextLost?: (event: Event) => void;\n  onContextRestored?: (event: Event) => void;\n  alpha?: boolean; // indicates if the canvas contains an alpha buffer.\n  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop\n  antialias?: boolean; // indicates whether or not to perform anti-aliasing.\n  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.\n  failIfMajorPerformanceCaveat?: boolean, // indicates if a context will be created if the system performance is low or if no hardware GPU is available.\n  powerPreference?: 'default' |  'high-performance' | 'low-power',\n  premultipliedAlpha?: boolean, // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.\n  preserveDrawingBuffer?: boolean // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.\n};\n\nconst DEFAULT_CONTEXT_PROPS: ContextProps = {\n  webgl2: true, // Attempt to create a WebGL2 context\n  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)\n  powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons\n  onContextLost: () => console.error('WebGL context lost'),\n  onContextRestored: () => console.info('WebGL context restored'),\n};\n\n/**\n * Create a WebGL context for a canvas\n * Note calling this multiple time on the same canvas does return the same context\n* @param canvas A canvas element or offscreen canvas\n */\n export function createBrowserContext(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): WebGLRenderingContext {\n   props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n  // Try to extract any extra information about why context creation failed\n  let errorMessage = null;\n  const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n  canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n  // Create the desired context\n  let gl: WebGLRenderingContext | null = null;\n\n  if (props.type === 'webgl2') {\n    props = {...props, webgl1: false};\n  }\n  if (props.type === 'webgl1') {\n    props = {...props, webgl2: false};\n  }\n\n  // Prefer webgl2 over webgl1 if both are acceptable\n  if (props.webgl2) {\n    gl = gl || canvas.getContext('webgl2', props) as WebGL2RenderingContext | null;\n  }\n  if (props.webgl1) {\n    gl = gl || canvas.getContext('webgl', props) as WebGLRenderingContext | null;\n  }\n\n  // TODO are we removing this listener before giving it a chance to fire?\n  canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n  if (!gl) {\n    throw new Error(\n      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${\n        errorMessage || 'Unknown error'\n      }`\n    );\n  }\n\n  if (props.onContextLost) {\n    // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.\n    const {onContextLost} = props;\n    canvas.addEventListener('webglcontextlost',(event: Event) => onContextLost(event), false);\n  }\n  if (props.onContextRestored) {\n    // Carefully extract and wrap callbacks to prevent addEventListener from rebinding them.\n    const {onContextRestored} = props;\n    canvas.addEventListener('webglcontextrestored', (event: Event) => onContextRestored(event), false);\n  }\n\n  return gl;\n}\n\n/* TODO - can we call this asynchronously to catch the error events?\nexport async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {\n  props = {...DEFAULT_CONTEXT_PROPS, ...props};\n\n // Try to extract any extra information about why context creation failed\n let errorMessage = null;\n const onCreateError = (error) => (errorMessage = error.statusMessage || errorMessage);\n canvas.addEventListener('webglcontextcreationerror', onCreateError, false);\n\n const gl = createBrowserContext(canvas, props);\n\n // Give the listener a chance to fire\n await new Promise(resolve => setTimeout(resolve, 0));\n\n canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);\n\n return gl;\n}\n*/\n"],"mappings":";;;;;;;;;;AAmCA,IAAMA,qBAAmC,GAAG;EAC1CC,MAAM,EAAE,IAAI;EACZC,MAAM,EAAE,IAAI;EACZC,eAAe,EAAE,kBAAkB;EACnCC,aAAa,EAAE,SAAAA,cAAA;IAAA,OAAMC,OAAO,CAACC,KAAK,CAAC,oBAAoB,CAAC;EAAA;EACxDC,iBAAiB,EAAE,SAAAA,kBAAA;IAAA,OAAMF,OAAO,CAACG,IAAI,CAAC,wBAAwB,CAAC;EAAA;AACjE,CAAC;AAOO,SAASC,oBAAoBA,CAACC,MAA2C,EAAEC,KAAmB,EAAyB;EAC5HA,KAAK,GAAAC,aAAA,CAAAA,aAAA,KAAOZ,qBAAqB,GAAKW,KAAK,CAAC;EAG7C,IAAIE,YAAY,GAAG,IAAI;EACvB,IAAMC,aAAa,GAAG,SAAhBA,aAAaA,CAAIR,KAAK;IAAA,OAAMO,YAAY,GAAGP,KAAK,CAACS,aAAa,IAAIF,YAAY;EAAA,CAAC;EACrFH,MAAM,CAACM,gBAAgB,CAAC,2BAA2B,EAAEF,aAAa,EAAE,KAAK,CAAC;EAG1E,IAAIG,EAAgC,GAAG,IAAI;EAE3C,IAAIN,KAAK,CAACO,IAAI,KAAK,QAAQ,EAAE;IAC3BP,KAAK,GAAAC,aAAA,CAAAA,aAAA,KAAOD,KAAK;MAAET,MAAM,EAAE;IAAK,EAAC;EACnC;EACA,IAAIS,KAAK,CAACO,IAAI,KAAK,QAAQ,EAAE;IAC3BP,KAAK,GAAAC,aAAA,CAAAA,aAAA,KAAOD,KAAK;MAAEV,MAAM,EAAE;IAAK,EAAC;EACnC;EAGA,IAAIU,KAAK,CAACV,MAAM,EAAE;IAChBgB,EAAE,GAAGA,EAAE,IAAIP,MAAM,CAACS,UAAU,CAAC,QAAQ,EAAER,KAAK,CAAkC;EAChF;EACA,IAAIA,KAAK,CAACT,MAAM,EAAE;IAChBe,EAAE,GAAGA,EAAE,IAAIP,MAAM,CAACS,UAAU,CAAC,OAAO,EAAER,KAAK,CAAiC;EAC9E;EAGAD,MAAM,CAACU,mBAAmB,CAAC,2BAA2B,EAAEN,aAAa,EAAE,KAAK,CAAC;EAE7E,IAAI,CAACG,EAAE,EAAE;IACP,MAAM,IAAII,KAAK,qBAAAC,MAAA,CACOX,KAAK,CAACV,MAAM,IAAI,CAACU,KAAK,CAACT,MAAM,GAAG,QAAQ,GAAG,OAAO,gBAAAoB,MAAA,CACpET,YAAY,IAAI,eAAe,EAElC;EACH;EAEA,IAAIF,KAAK,CAACP,aAAa,EAAE;IAEvB,IAAAmB,MAAA,GAAwBZ,KAAK;MAAtBP,aAAa,GAAAmB,MAAA,CAAbnB,aAAa;IACpBM,MAAM,CAACM,gBAAgB,CAAC,kBAAkB,EAAC,UAACQ,KAAY;MAAA,OAAKpB,aAAa,CAACoB,KAAK,CAAC;IAAA,GAAE,KAAK,CAAC;EAC3F;EACA,IAAIb,KAAK,CAACJ,iBAAiB,EAAE;IAE3B,IAAAkB,OAAA,GAA4Bd,KAAK;MAA1BJ,iBAAiB,GAAAkB,OAAA,CAAjBlB,iBAAiB;IACxBG,MAAM,CAACM,gBAAgB,CAAC,sBAAsB,EAAE,UAACQ,KAAY;MAAA,OAAKjB,iBAAiB,CAACiB,KAAK,CAAC;IAAA,GAAE,KAAK,CAAC;EACpG;EAEA,OAAOP,EAAE;AACX"}

package/dist/es5/context/context/create-headless-context.js

@@ -1,20 +1,15 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.registerHeadlessGL = registerHeadlessGL;
-exports.isHeadlessGLRegistered = isHeadlessGLRegistered;
 exports.createHeadlessContext = createHeadlessContext;
-
+exports.isHeadlessGLRegistered = isHeadlessGLRegistered;
+exports.registerHeadlessGL = registerHeadlessGL;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var ERR_HEADLESSGL_FAILED = 'Failed to create WebGL context in Node.js, headless gl returned null';
 var ERR_HEADLESSGL_LOAD = "  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL   contexts can not be created. This may not be an error. For example, this is a   typical configuration for isorender applications running on the server.";
 var CONTEXT_DEFAULTS = {
@@ -24,37 +19,29 @@ var CONTEXT_DEFAULTS = {
   throwOnError: false
 };
 var headlessGL = null;
-
 function registerHeadlessGL(headlessgl) {
   headlessGL = headlessgl;
 }
-
 function isHeadlessGLRegistered() {
   return headlessGL !== null;
 }
-
 function createHeadlessContext(options) {
   options = _objectSpread(_objectSpread({}, CONTEXT_DEFAULTS), options);
   var _options = options,
-      width = _options.width,
-      height = _options.height,
-      webgl1 = _options.webgl1,
-      webgl2 = _options.webgl2;
-
+    width = _options.width,
+    height = _options.height,
+    webgl1 = _options.webgl1,
+    webgl2 = _options.webgl2;
   if (webgl2 && !webgl1) {
     throw new Error('headless-gl does not support WebGL2');
   }
-
   if (!headlessGL) {
     throw new Error(ERR_HEADLESSGL_LOAD);
   }
-
   var gl = headlessGL(width, height, options);
-
   if (!gl) {
     throw new Error(ERR_HEADLESSGL_FAILED);
   }
-
   return gl;
 }
 //# sourceMappingURL=create-headless-context.js.map

package/dist/es5/context/context/create-headless-context.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/context/context/create-headless-context.ts"],"names":["ERR_HEADLESSGL_FAILED","ERR_HEADLESSGL_LOAD","CONTEXT_DEFAULTS","width","height","debug","throwOnError","headlessGL","registerHeadlessGL","headlessgl","isHeadlessGLRegistered","createHeadlessContext","options","webgl1","webgl2","Error","gl"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAMA,qBAAqB,GACzB,sEADF;AAGA,IAAMC,mBAAmB,gPAAzB;AAKA,IAAMC,gBAAgB,GAAG;AACvBC,EAAAA,KAAK,EAAE,CADgB;AAEvBC,EAAAA,MAAM,EAAE,CAFe;AAGvBC,EAAAA,KAAK,EAAE,IAHgB;AAIvBC,EAAAA,YAAY,EAAE;AAJS,CAAzB;AAUA,IAAIC,UAA6B,GAAG,IAApC;;AAGO,SAASC,kBAAT,CAA4BC,UAA5B,EAAoD;AACzDF,EAAAA,UAAU,GAAGE,UAAb;AACD;;AAGM,SAASC,sBAAT,GAA2C;AAChD,SAAOH,UAAU,KAAK,IAAtB;AACD;;AAGM,SAASI,qBAAT,CAA+BC,OAA/B,EAAqF;AAC1FA,EAAAA,OAAO,mCAAOV,gBAAP,GAA4BU,OAA5B,CAAP;AAEA,iBAAwCA,OAAxC;AAAA,MAAOT,KAAP,YAAOA,KAAP;AAAA,MAAcC,MAAd,YAAcA,MAAd;AAAA,MAAsBS,MAAtB,YAAsBA,MAAtB;AAAA,MAA8BC,MAA9B,YAA8BA,MAA9B;;AAEA,MAAIA,MAAM,IAAI,CAACD,MAAf,EAAuB;AACrB,UAAM,IAAIE,KAAJ,CAAU,qCAAV,CAAN;AACD;;AACD,MAAI,CAACR,UAAL,EAAiB;AACf,UAAM,IAAIQ,KAAJ,CAAUd,mBAAV,CAAN;AACD;;AACD,MAAMe,EAAE,GAAGT,UAAU,CAACJ,KAAD,EAAQC,MAAR,EAAgBQ,OAAhB,CAArB;;AACA,MAAI,CAACI,EAAL,EAAS;AACP,UAAM,IAAID,KAAJ,CAAUf,qBAAV,CAAN;AACD;;AACD,SAAOgB,EAAP;AACD","sourcesContent":["const ERR_HEADLESSGL_FAILED =\n  'Failed to create WebGL context in Node.js, headless gl returned null';\n\nconst ERR_HEADLESSGL_LOAD = `\\\n  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL \\\n  contexts can not be created. This may not be an error. For example, this is a \\\n  typical configuration for isorender applications running on the server.`;\n\nconst CONTEXT_DEFAULTS = {\n  width: 1,\n  height: 1,\n  debug: true,\n  throwOnError: false\n};\n\n/** Duck typing for the main headless gl export, a function to create contexts */\nexport type HeadlessGL = (width: number, height: number, options: Record<string, unknown>) => WebGLRenderingContext;\n\nlet headlessGL: HeadlessGL | null = null; \n\n/** By importing `gl` and registering it with this function, contexts can be created under Node.js */\nexport function registerHeadlessGL(headlessgl: HeadlessGL) {\n  headlessGL = headlessgl;\n}\n\n/** @returns true if headless gl is registered */\nexport function isHeadlessGLRegistered(): boolean {\n  return headlessGL !== null;\n}\n\n/** Create headless gl context (for running under Node.js) */\nexport function createHeadlessContext(options?: Record<string, any>): WebGLRenderingContext {\n  options = {...CONTEXT_DEFAULTS, ...options};\n\n  const {width, height, webgl1, webgl2} = options;\n\n  if (webgl2 && !webgl1) {\n    throw new Error('headless-gl does not support WebGL2');\n  }\n  if (!headlessGL) {\n    throw new Error(ERR_HEADLESSGL_LOAD);\n  }\n  const gl = headlessGL(width, height, options);\n  if (!gl) {\n    throw new Error(ERR_HEADLESSGL_FAILED);\n  }\n  return gl;\n}\n"],"file":"create-headless-context.js"}
+{"version":3,"file":"create-headless-context.js","names":["ERR_HEADLESSGL_FAILED","ERR_HEADLESSGL_LOAD","CONTEXT_DEFAULTS","width","height","debug","throwOnError","headlessGL","registerHeadlessGL","headlessgl","isHeadlessGLRegistered","createHeadlessContext","options","_objectSpread","_options","webgl1","webgl2","Error","gl"],"sources":["../../../../src/context/context/create-headless-context.ts"],"sourcesContent":["const ERR_HEADLESSGL_FAILED =\n  'Failed to create WebGL context in Node.js, headless gl returned null';\n\nconst ERR_HEADLESSGL_LOAD = `\\\n  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL \\\n  contexts can not be created. This may not be an error. For example, this is a \\\n  typical configuration for isorender applications running on the server.`;\n\nconst CONTEXT_DEFAULTS = {\n  width: 1,\n  height: 1,\n  debug: true,\n  throwOnError: false\n};\n\n/** Duck typing for the main headless gl export, a function to create contexts */\nexport type HeadlessGL = (width: number, height: number, options: Record<string, unknown>) => WebGLRenderingContext;\n\nlet headlessGL: HeadlessGL | null = null; \n\n/** By importing `gl` and registering it with this function, contexts can be created under Node.js */\nexport function registerHeadlessGL(headlessgl: HeadlessGL) {\n  headlessGL = headlessgl;\n}\n\n/** @returns true if headless gl is registered */\nexport function isHeadlessGLRegistered(): boolean {\n  return headlessGL !== null;\n}\n\n/** Create headless gl context (for running under Node.js) */\nexport function createHeadlessContext(options?: Record<string, any>): WebGLRenderingContext {\n  options = {...CONTEXT_DEFAULTS, ...options};\n\n  const {width, height, webgl1, webgl2} = options;\n\n  if (webgl2 && !webgl1) {\n    throw new Error('headless-gl does not support WebGL2');\n  }\n  if (!headlessGL) {\n    throw new Error(ERR_HEADLESSGL_LOAD);\n  }\n  const gl = headlessGL(width, height, options);\n  if (!gl) {\n    throw new Error(ERR_HEADLESSGL_FAILED);\n  }\n  return gl;\n}\n"],"mappings":";;;;;;;;;;;;AAAA,IAAMA,qBAAqB,GACzB,sEAAsE;AAExE,IAAMC,mBAAmB,gPAGiD;AAE1E,IAAMC,gBAAgB,GAAG;EACvBC,KAAK,EAAE,CAAC;EACRC,MAAM,EAAE,CAAC;EACTC,KAAK,EAAE,IAAI;EACXC,YAAY,EAAE;AAChB,CAAC;AAKD,IAAIC,UAA6B,GAAG,IAAI;AAGjC,SAASC,kBAAkBA,CAACC,UAAsB,EAAE;EACzDF,UAAU,GAAGE,UAAU;AACzB;AAGO,SAASC,sBAAsBA,CAAA,EAAY;EAChD,OAAOH,UAAU,KAAK,IAAI;AAC5B;AAGO,SAASI,qBAAqBA,CAACC,OAA6B,EAAyB;EAC1FA,OAAO,GAAAC,aAAA,CAAAA,aAAA,KAAOX,gBAAgB,GAAKU,OAAO,CAAC;EAE3C,IAAAE,QAAA,GAAwCF,OAAO;IAAxCT,KAAK,GAAAW,QAAA,CAALX,KAAK;IAAEC,MAAM,GAAAU,QAAA,CAANV,MAAM;IAAEW,MAAM,GAAAD,QAAA,CAANC,MAAM;IAAEC,MAAM,GAAAF,QAAA,CAANE,MAAM;EAEpC,IAAIA,MAAM,IAAI,CAACD,MAAM,EAAE;IACrB,MAAM,IAAIE,KAAK,CAAC,qCAAqC,CAAC;EACxD;EACA,IAAI,CAACV,UAAU,EAAE;IACf,MAAM,IAAIU,KAAK,CAAChB,mBAAmB,CAAC;EACtC;EACA,IAAMiB,EAAE,GAAGX,UAAU,CAACJ,KAAK,EAAEC,MAAM,EAAEQ,OAAO,CAAC;EAC7C,IAAI,CAACM,EAAE,EAAE;IACP,MAAM,IAAID,KAAK,CAACjB,qBAAqB,CAAC;EACxC;EACA,OAAOkB,EAAE;AACX"}

package/dist/es5/context/context/webgl-checks.js

@@ -3,50 +3,40 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.ERR_WEBGL2 = exports.ERR_WEBGL = void 0;
+exports.assertWebGL2Context = assertWebGL2Context;
+exports.assertWebGLContext = assertWebGLContext;
+exports.getWebGL2Context = getWebGL2Context;
 exports.isWebGL = isWebGL;
 exports.isWebGL2 = isWebGL2;
-exports.getWebGL2Context = getWebGL2Context;
-exports.assertWebGLContext = assertWebGLContext;
-exports.assertWebGL2Context = assertWebGL2Context;
-exports.ERR_WEBGL2 = exports.ERR_WEBGL = void 0;
-
 var _api = require("@luma.gl/api");
-
 var ERR_CONTEXT = 'Invalid WebGLRenderingContext';
 var ERR_WEBGL = ERR_CONTEXT;
 exports.ERR_WEBGL = ERR_WEBGL;
 var ERR_WEBGL2 = 'Requires WebGL2';
 exports.ERR_WEBGL2 = ERR_WEBGL2;
-
 function isWebGL(gl) {
   if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {
     return true;
   }
-
   if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-
   return Boolean(gl && Number.isFinite(gl._version));
 }
-
 function isWebGL2(gl) {
   if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-
   return Boolean(gl && gl._version === 2);
 }
-
 function getWebGL2Context(gl) {
   return isWebGL2(gl) ? gl : null;
 }
-
 function assertWebGLContext(gl) {
   (0, _api.assert)(isWebGL(gl), ERR_CONTEXT);
   return gl;
 }
-
 function assertWebGL2Context(gl) {
   (0, _api.assert)(isWebGL2(gl), ERR_WEBGL2);
   return gl;

package/dist/es5/context/context/webgl-checks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/context/context/webgl-checks.ts"],"names":["ERR_CONTEXT","ERR_WEBGL","ERR_WEBGL2","isWebGL","gl","WebGLRenderingContext","WebGL2RenderingContext","Boolean","Number","isFinite","_version","isWebGL2","getWebGL2Context","assertWebGLContext","assertWebGL2Context"],"mappings":";;;;;;;;;;;;AACA;;AAEA,IAAMA,WAAW,GAAG,+BAApB;AACO,IAAMC,SAAS,GAAGD,WAAlB;;AACA,IAAME,UAAU,GAAG,iBAAnB;;;AAIA,SAASC,OAAT,CAAiBC,EAAjB,EAAmC;AACxC,MAAI,OAAOC,qBAAP,KAAiC,WAAjC,IAAgDD,EAAE,YAAYC,qBAAlE,EAAyF;AACvF,WAAO,IAAP;AACD;;AACD,MAAI,OAAOC,sBAAP,KAAkC,WAAlC,IAAiDF,EAAE,YAAYE,sBAAnE,EAA2F;AACzF,WAAO,IAAP;AACD;;AAED,SAAOC,OAAO,CAACH,EAAE,IAAII,MAAM,CAACC,QAAP,CAAgBL,EAAE,CAACM,QAAnB,CAAP,CAAd;AACD;;AAIM,SAASC,QAAT,CAAkBP,EAAlB,EAAoC;AACzC,MAAI,OAAOE,sBAAP,KAAkC,WAAlC,IAAiDF,EAAE,YAAYE,sBAAnE,EAA2F;AACzF,WAAO,IAAP;AACD;;AAED,SAAOC,OAAO,CAACH,EAAE,IAAIA,EAAE,CAACM,QAAH,KAAgB,CAAvB,CAAd;AACD;;AAIM,SAASE,gBAAT,CAA0BR,EAA1B,EAAoF;AAEzF,SAAOO,QAAQ,CAACP,EAAD,CAAR,GAAeA,EAAf,GAAoB,IAA3B;AACD;;AAIM,SAASS,kBAAT,CAA4BT,EAA5B,EAA4D;AACjE,mBAAOD,OAAO,CAACC,EAAD,CAAd,EAAoBJ,WAApB;AACA,SAAOI,EAAP;AACD;;AAGM,SAASU,mBAAT,CAA6BV,EAA7B,EAA8D;AACnE,mBAAOO,QAAQ,CAACP,EAAD,CAAf,EAAqBF,UAArB;AACA,SAAOE,EAAP;AACD","sourcesContent":["// luma.gl, MIT license\nimport {assert} from '@luma.gl/api';\n\nconst ERR_CONTEXT = 'Invalid WebGLRenderingContext';\nexport const ERR_WEBGL = ERR_CONTEXT;\nexport const ERR_WEBGL2 = 'Requires WebGL2';\n\n\n/** Check if supplied parameter is a WebGLRenderingContext */\nexport function isWebGL(gl: any): boolean {\n  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {\n    return true;\n  }\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && Number.isFinite(gl._version));\n}\n\n\n/** Check if supplied parameter is a WebGL2RenderingContext */\nexport function isWebGL2(gl: any): boolean {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && gl._version === 2);\n}\n\n\n/** Returns a properly typed WebGL2RenderingContext from a WebGL1 context, or null */\nexport function getWebGL2Context(gl: WebGLRenderingContext): WebGL2RenderingContext | null {\n  // @ts-expect-error\n  return isWebGL2(gl) ? gl : null;\n}\n\n\n/** Throw if supplied parameter is not a WebGLRenderingContext, otherwise return properly typed value */\nexport function assertWebGLContext(gl: any): WebGLRenderingContext {\n  assert(isWebGL(gl), ERR_CONTEXT);\n  return gl;\n}\n\n/** Throw if supplied parameter is not a WebGL2RenderingContext, otherwise return properly typed value */\nexport function assertWebGL2Context(gl: any): WebGL2RenderingContext {\n  assert(isWebGL2(gl), ERR_WEBGL2);\n  return gl;\n}\n"],"file":"webgl-checks.js"}
+{"version":3,"file":"webgl-checks.js","names":["_api","require","ERR_CONTEXT","ERR_WEBGL","exports","ERR_WEBGL2","isWebGL","gl","WebGLRenderingContext","WebGL2RenderingContext","Boolean","Number","isFinite","_version","isWebGL2","getWebGL2Context","assertWebGLContext","assert","assertWebGL2Context"],"sources":["../../../../src/context/context/webgl-checks.ts"],"sourcesContent":["// luma.gl, MIT license\nimport {assert} from '@luma.gl/api';\n\nconst ERR_CONTEXT = 'Invalid WebGLRenderingContext';\nexport const ERR_WEBGL = ERR_CONTEXT;\nexport const ERR_WEBGL2 = 'Requires WebGL2';\n\n\n/** Check if supplied parameter is a WebGLRenderingContext */\nexport function isWebGL(gl: any): boolean {\n  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {\n    return true;\n  }\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && Number.isFinite(gl._version));\n}\n\n\n/** Check if supplied parameter is a WebGL2RenderingContext */\nexport function isWebGL2(gl: any): boolean {\n  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {\n    return true;\n  }\n  // Look for debug contexts, headless gl etc\n  return Boolean(gl && gl._version === 2);\n}\n\n\n/** Returns a properly typed WebGL2RenderingContext from a WebGL1 context, or null */\nexport function getWebGL2Context(gl: WebGLRenderingContext): WebGL2RenderingContext | null {\n  // @ts-expect-error\n  return isWebGL2(gl) ? gl : null;\n}\n\n\n/** Throw if supplied parameter is not a WebGLRenderingContext, otherwise return properly typed value */\nexport function assertWebGLContext(gl: any): WebGLRenderingContext {\n  assert(isWebGL(gl), ERR_CONTEXT);\n  return gl;\n}\n\n/** Throw if supplied parameter is not a WebGL2RenderingContext, otherwise return properly typed value */\nexport function assertWebGL2Context(gl: any): WebGL2RenderingContext {\n  assert(isWebGL2(gl), ERR_WEBGL2);\n  return gl;\n}\n"],"mappings":";;;;;;;;;;;AACA,IAAAA,IAAA,GAAAC,OAAA;AAEA,IAAMC,WAAW,GAAG,+BAA+B;AAC5C,IAAMC,SAAS,GAAGD,WAAW;AAACE,OAAA,CAAAD,SAAA,GAAAA,SAAA;AAC9B,IAAME,UAAU,GAAG,iBAAiB;AAACD,OAAA,CAAAC,UAAA,GAAAA,UAAA;AAIrC,SAASC,OAAOA,CAACC,EAAO,EAAW;EACxC,IAAI,OAAOC,qBAAqB,KAAK,WAAW,IAAID,EAAE,YAAYC,qBAAqB,EAAE;IACvF,OAAO,IAAI;EACb;EACA,IAAI,OAAOC,sBAAsB,KAAK,WAAW,IAAIF,EAAE,YAAYE,sBAAsB,EAAE;IACzF,OAAO,IAAI;EACb;EAEA,OAAOC,OAAO,CAACH,EAAE,IAAII,MAAM,CAACC,QAAQ,CAACL,EAAE,CAACM,QAAQ,CAAC,CAAC;AACpD;AAIO,SAASC,QAAQA,CAACP,EAAO,EAAW;EACzC,IAAI,OAAOE,sBAAsB,KAAK,WAAW,IAAIF,EAAE,YAAYE,sBAAsB,EAAE;IACzF,OAAO,IAAI;EACb;EAEA,OAAOC,OAAO,CAACH,EAAE,IAAIA,EAAE,CAACM,QAAQ,KAAK,CAAC,CAAC;AACzC;AAIO,SAASE,gBAAgBA,CAACR,EAAyB,EAAiC;EAEzF,OAAOO,QAAQ,CAACP,EAAE,CAAC,GAAGA,EAAE,GAAG,IAAI;AACjC;AAIO,SAASS,kBAAkBA,CAACT,EAAO,EAAyB;EACjE,IAAAU,WAAM,EAACX,OAAO,CAACC,EAAE,CAAC,EAAEL,WAAW,CAAC;EAChC,OAAOK,EAAE;AACX;AAGO,SAASW,mBAAmBA,CAACX,EAAO,EAA0B;EACnE,IAAAU,WAAM,EAACH,QAAQ,CAACP,EAAE,CAAC,EAAEF,UAAU,CAAC;EAChC,OAAOE,EAAE;AACX"}

package/dist/es5/context/debug/spector.js

@@ -1,25 +1,17 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadSpectorJS = loadSpectorJS;
 exports.initializeSpectorJS = initializeSpectorJS;
-
+exports.loadSpectorJS = loadSpectorJS;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
 var _api = require("@luma.gl/api");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var DEFAULT_SPECTOR_PROPS = {
   spector: _api.log.get('spector') || _api.log.get('inspect')
 };
@@ -27,72 +19,54 @@ var SPECTOR_CDN_URL = 'https://spectorcdn.babylonjs.com/spector.bundle.js';
 var LOG_LEVEL = 1;
 var spector = null;
 var initialized = false;
-
 function loadSpectorJS(_x) {
   return _loadSpectorJS.apply(this, arguments);
 }
-
 function _loadSpectorJS() {
   _loadSpectorJS = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(props) {
     return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            if (globalThis.SPECTOR) {
-              _context.next = 9;
-              break;
-            }
-
-            _context.prev = 1;
-            _context.next = 4;
-            return (0, _api.loadScript)(SPECTOR_CDN_URL);
-
-          case 4:
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (globalThis.SPECTOR) {
             _context.next = 9;
             break;
-
-          case 6:
-            _context.prev = 6;
-            _context.t0 = _context["catch"](1);
-
-            _api.log.warn(String(_context.t0));
-
-          case 9:
-          case "end":
-            return _context.stop();
-        }
+          }
+          _context.prev = 1;
+          _context.next = 4;
+          return (0, _api.loadScript)(SPECTOR_CDN_URL);
+        case 4:
+          _context.next = 9;
+          break;
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](1);
+          _api.log.warn(String(_context.t0));
+        case 9:
+        case "end":
+          return _context.stop();
       }
     }, _callee, null, [[1, 6]]);
   }));
   return _loadSpectorJS.apply(this, arguments);
 }
-
 function initializeSpectorJS(props) {
   var _props, _props2;
-
   props = _objectSpread(_objectSpread({}, DEFAULT_SPECTOR_PROPS), props);
-
   if (!((_props = props) !== null && _props !== void 0 && _props.spector)) {
     return null;
   }
-
   if (!spector && globalThis.SPECTOR) {
     _api.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
-
     spector = new globalThis.SPECTOR.Spector();
-
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
     }
   }
-
   if (!spector) {
     return null;
   }
-
   if (!initialized) {
     var _spector, _spector2;
-
     initialized = true;
     spector.spyCanvases();
     (_spector = spector) === null || _spector === void 0 ? void 0 : _spector.onCaptureStarted.add(function (capture) {
@@ -100,34 +74,26 @@ function initializeSpectorJS(props) {
     });
     (_spector2 = spector) === null || _spector2 === void 0 ? void 0 : _spector2.onCapture.add(function (capture) {
       var _spector3, _spector4, _spector5;
-
       _api.log.info("Spector capture complete:", capture)();
-
       (_spector3 = spector) === null || _spector3 === void 0 ? void 0 : _spector3.getResultUI();
       (_spector4 = spector) === null || _spector4 === void 0 ? void 0 : _spector4.resultView.display();
       (_spector5 = spector) === null || _spector5 === void 0 ? void 0 : _spector5.resultView.addCapture(capture);
     });
   }
-
   if ((_props2 = props) !== null && _props2 !== void 0 && _props2.canvas) {
     var _spector6, _props3;
-
     if (typeof props.spector === 'string' && props.spector !== props.canvas.id) {
       return spector;
     }
-
     (_spector6 = spector) === null || _spector6 === void 0 ? void 0 : _spector6.startCapture((_props3 = props) === null || _props3 === void 0 ? void 0 : _props3.canvas, 500);
     new Promise(function (resolve) {
       return setTimeout(resolve, 2000);
     }).then(function (_) {
       var _spector7;
-
       _api.log.info("Spector capture stopped after 2 seconds")();
-
       (_spector7 = spector) === null || _spector7 === void 0 ? void 0 : _spector7.stopCapture();
     });
   }
-
   return spector;
 }
 //# sourceMappingURL=spector.js.map