@deck.gl/extensions 8.7.0-alpha.3 → 8.7.0-beta.1

package/dist/es5/fp64/fp64.js

@@ -7,26 +7,50 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _core = require("@deck.gl/core");
 
 var _project = _interopRequireDefault(require("./project64"));
 
-class Fp64Extension extends _core.LayerExtension {
-  getShaders(opts) {
-    const {
-      coordinateSystem
-    } = this.props;
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 
-    if (coordinateSystem !== _core.COORDINATE_SYSTEM.LNGLAT && coordinateSystem !== _core.COORDINATE_SYSTEM.DEFAULT) {
-      throw new Error('fp64: coordinateSystem must be LNGLAT');
-    }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-    return {
-      modules: [_project.default]
-    };
+var Fp64Extension = function (_LayerExtension) {
+  (0, _inherits2.default)(Fp64Extension, _LayerExtension);
+
+  var _super = _createSuper(Fp64Extension);
+
+  function Fp64Extension() {
+    (0, _classCallCheck2.default)(this, Fp64Extension);
+    return _super.apply(this, arguments);
   }
 
-}
+  (0, _createClass2.default)(Fp64Extension, [{
+    key: "getShaders",
+    value: function getShaders(opts) {
+      var coordinateSystem = this.props.coordinateSystem;
+
+      if (coordinateSystem !== _core.COORDINATE_SYSTEM.LNGLAT && coordinateSystem !== _core.COORDINATE_SYSTEM.DEFAULT) {
+        throw new Error('fp64: coordinateSystem must be LNGLAT');
+      }
+
+      return {
+        modules: [_project.default]
+      };
+    }
+  }]);
+  return Fp64Extension;
+}(_core.LayerExtension);
 
 exports.default = Fp64Extension;
 Fp64Extension.extensionName = 'Fp64Extension';

package/dist/es5/fp64/fp64.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/fp64/fp64.js"],"names":["Fp64Extension","LayerExtension","getShaders","opts","coordinateSystem","props","COORDINATE_SYSTEM","LNGLAT","DEFAULT","Error","modules","project64","extensionName"],"mappings":";;;;;;;;;AAoBA;;AACA;;AAEe,MAAMA,aAAN,SAA4BC,oBAA5B,CAA2C;AACxDC,EAAAA,UAAU,CAACC,IAAD,EAAO;AACf,UAAM;AAACC,MAAAA;AAAD,QAAqB,KAAKC,KAAhC;;AACA,QACED,gBAAgB,KAAKE,wBAAkBC,MAAvC,IACAH,gBAAgB,KAAKE,wBAAkBE,OAFzC,EAGE;AACA,YAAM,IAAIC,KAAJ,CAAU,uCAAV,CAAN;AACD;;AAED,WAAO;AACLC,MAAAA,OAAO,EAAE,CAACC,gBAAD;AADJ,KAAP;AAGD;;AAbuD;;;AAgB1DX,aAAa,CAACY,aAAd,GAA8B,eAA9B","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {LayerExtension, COORDINATE_SYSTEM} from '@deck.gl/core';\nimport project64 from './project64';\n\nexport default class Fp64Extension extends LayerExtension {\n  getShaders(opts) {\n    const {coordinateSystem} = this.props;\n    if (\n      coordinateSystem !== COORDINATE_SYSTEM.LNGLAT &&\n      coordinateSystem !== COORDINATE_SYSTEM.DEFAULT\n    ) {\n      throw new Error('fp64: coordinateSystem must be LNGLAT');\n    }\n\n    return {\n      modules: [project64]\n    };\n  }\n}\n\nFp64Extension.extensionName = 'Fp64Extension';\n"],"file":"fp64.js"}
+{"version":3,"sources":["../../../src/fp64/fp64.js"],"names":["Fp64Extension","opts","coordinateSystem","props","COORDINATE_SYSTEM","LNGLAT","DEFAULT","Error","modules","project64","LayerExtension","extensionName"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA;;AACA;;;;;;IAEqBA,a;;;;;;;;;;;;WACnB,oBAAWC,IAAX,EAAiB;AACf,UAAOC,gBAAP,GAA2B,KAAKC,KAAhC,CAAOD,gBAAP;;AACA,UACEA,gBAAgB,KAAKE,wBAAkBC,MAAvC,IACAH,gBAAgB,KAAKE,wBAAkBE,OAFzC,EAGE;AACA,cAAM,IAAIC,KAAJ,CAAU,uCAAV,CAAN;AACD;;AAED,aAAO;AACLC,QAAAA,OAAO,EAAE,CAACC,gBAAD;AADJ,OAAP;AAGD;;;EAbwCC,oB;;;AAgB3CV,aAAa,CAACW,aAAd,GAA8B,eAA9B","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {LayerExtension, COORDINATE_SYSTEM} from '@deck.gl/core';\nimport project64 from './project64';\n\nexport default class Fp64Extension extends LayerExtension {\n  getShaders(opts) {\n    const {coordinateSystem} = this.props;\n    if (\n      coordinateSystem !== COORDINATE_SYSTEM.LNGLAT &&\n      coordinateSystem !== COORDINATE_SYSTEM.DEFAULT\n    ) {\n      throw new Error('fp64: coordinateSystem must be LNGLAT');\n    }\n\n    return {\n      modules: [project64]\n    };\n  }\n}\n\nFp64Extension.extensionName = 'Fp64Extension';\n"],"file":"fp64.js"}

package/dist/es5/fp64/project64.js

@@ -13,41 +13,39 @@ var _core = require("@deck.gl/core");
 
 var _project = _interopRequireDefault(require("./project64.glsl"));
 
-const {
-  fp64ify,
-  fp64ifyMatrix4
-} = _shadertools.fp64;
+var fp64ify = _shadertools.fp64.fp64ify,
+    fp64ifyMatrix4 = _shadertools.fp64.fp64ifyMatrix4;
 var _default = {
   name: 'project64',
   dependencies: [_core.project, _shadertools.fp64],
   vs: _project.default,
-  getUniforms
+  getUniforms: getUniforms
 };
 exports.default = _default;
-const DEFAULT_MODULE_OPTIONS = {};
-const getMemoizedUniforms = (0, _core._memoize)(calculateUniforms);
+var DEFAULT_MODULE_OPTIONS = {};
+var getMemoizedUniforms = (0, _core._memoize)(calculateUniforms);
+
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_MODULE_OPTIONS;
 
-function getUniforms(opts = DEFAULT_MODULE_OPTIONS) {
   if (opts.viewport) {
-    const {
-      viewProjectionMatrix,
-      scale
-    } = opts.viewport;
+    var _opts$viewport = opts.viewport,
+        viewProjectionMatrix = _opts$viewport.viewProjectionMatrix,
+        scale = _opts$viewport.scale;
     return getMemoizedUniforms({
-      viewProjectionMatrix,
-      scale
+      viewProjectionMatrix: viewProjectionMatrix,
+      scale: scale
     });
   }
 
   return {};
 }
 
-function calculateUniforms({
-  viewProjectionMatrix,
-  scale
-}) {
-  const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);
-  const scaleFP64 = fp64ify(scale);
+function calculateUniforms(_ref) {
+  var viewProjectionMatrix = _ref.viewProjectionMatrix,
+      scale = _ref.scale;
+  var glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);
+  var scaleFP64 = fp64ify(scale);
   return {
     project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,
     project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,

package/dist/es5/fp64/project64.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/fp64/project64.js"],"names":["fp64ify","fp64ifyMatrix4","fp64","name","dependencies","project","vs","project64Shader","getUniforms","DEFAULT_MODULE_OPTIONS","getMemoizedUniforms","calculateUniforms","opts","viewport","viewProjectionMatrix","scale","glViewProjectionMatrixFP64","scaleFP64","project_uViewProjectionMatrixFP64","project64_uViewProjectionMatrix","project64_uScale"],"mappings":";;;;;;;;;AAoBA;;AAEA;;AAEA;;AAHA,MAAM;AAACA,EAAAA,OAAD;AAAUC,EAAAA;AAAV,IAA4BC,iBAAlC;eAKe;AACbC,EAAAA,IAAI,EAAE,WADO;AAEbC,EAAAA,YAAY,EAAE,CAACC,aAAD,EAAUH,iBAAV,CAFD;AAGbI,EAAAA,EAAE,EAAEC,gBAHS;AAIbC,EAAAA;AAJa,C;;AAUf,MAAMC,sBAAsB,GAAG,EAA/B;AACA,MAAMC,mBAAmB,GAAG,oBAAQC,iBAAR,CAA5B;;AAEA,SAASH,WAAT,CAAqBI,IAAI,GAAGH,sBAA5B,EAAoD;AAClD,MAAIG,IAAI,CAACC,QAAT,EAAmB;AACjB,UAAM;AAACC,MAAAA,oBAAD;AAAuBC,MAAAA;AAAvB,QAAgCH,IAAI,CAACC,QAA3C;AAEA,WAAOH,mBAAmB,CAAC;AAACI,MAAAA,oBAAD;AAAuBC,MAAAA;AAAvB,KAAD,CAA1B;AACD;;AACD,SAAO,EAAP;AACD;;AAED,SAASJ,iBAAT,CAA2B;AAACG,EAAAA,oBAAD;AAAuBC,EAAAA;AAAvB,CAA3B,EAA0D;AACxD,QAAMC,0BAA0B,GAAGf,cAAc,CAACa,oBAAD,CAAjD;AACA,QAAMG,SAAS,GAAGjB,OAAO,CAACe,KAAD,CAAzB;AAEA,SAAO;AACLG,IAAAA,iCAAiC,EAAEF,0BAD9B;AAELG,IAAAA,+BAA+B,EAAEH,0BAF5B;AAGLI,IAAAA,gBAAgB,EAAEH;AAHb,GAAP;AAKD","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {fp64} from '@luma.gl/shadertools';\nconst {fp64ify, fp64ifyMatrix4} = fp64;\nimport {project, _memoize as memoize} from '@deck.gl/core';\n\nimport project64Shader from './project64.glsl';\n\nexport default {\n  name: 'project64',\n  dependencies: [project, fp64],\n  vs: project64Shader,\n  getUniforms\n};\n\n// TODO - this module should calculate the 64 bit uniforms\n// It is currently done by project to minimize duplicated work\n\nconst DEFAULT_MODULE_OPTIONS = {};\nconst getMemoizedUniforms = memoize(calculateUniforms);\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n  if (opts.viewport) {\n    const {viewProjectionMatrix, scale} = opts.viewport;\n    // We only need to update fp64 uniforms if fp32 projection is being updated\n    return getMemoizedUniforms({viewProjectionMatrix, scale});\n  }\n  return {};\n}\n\nfunction calculateUniforms({viewProjectionMatrix, scale}) {\n  const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);\n  const scaleFP64 = fp64ify(scale);\n\n  return {\n    project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,\n    project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,\n    project64_uScale: scaleFP64\n  };\n}\n"],"file":"project64.js"}
+{"version":3,"sources":["../../../src/fp64/project64.js"],"names":["fp64ify","fp64","fp64ifyMatrix4","name","dependencies","project","vs","project64Shader","getUniforms","DEFAULT_MODULE_OPTIONS","getMemoizedUniforms","calculateUniforms","opts","viewport","viewProjectionMatrix","scale","glViewProjectionMatrixFP64","scaleFP64","project_uViewProjectionMatrixFP64","project64_uViewProjectionMatrix","project64_uScale"],"mappings":";;;;;;;;;AAoBA;;AAEA;;AAEA;;AAHA,IAAOA,OAAP,GAAkCC,iBAAlC,CAAOD,OAAP;AAAA,IAAgBE,cAAhB,GAAkCD,iBAAlC,CAAgBC,cAAhB;eAKe;AACbC,EAAAA,IAAI,EAAE,WADO;AAEbC,EAAAA,YAAY,EAAE,CAACC,aAAD,EAAUJ,iBAAV,CAFD;AAGbK,EAAAA,EAAE,EAAEC,gBAHS;AAIbC,EAAAA,WAAW,EAAXA;AAJa,C;;AAUf,IAAMC,sBAAsB,GAAG,EAA/B;AACA,IAAMC,mBAAmB,GAAG,oBAAQC,iBAAR,CAA5B;;AAEA,SAASH,WAAT,GAAoD;AAAA,MAA/BI,IAA+B,uEAAxBH,sBAAwB;;AAClD,MAAIG,IAAI,CAACC,QAAT,EAAmB;AACjB,yBAAsCD,IAAI,CAACC,QAA3C;AAAA,QAAOC,oBAAP,kBAAOA,oBAAP;AAAA,QAA6BC,KAA7B,kBAA6BA,KAA7B;AAEA,WAAOL,mBAAmB,CAAC;AAACI,MAAAA,oBAAoB,EAApBA,oBAAD;AAAuBC,MAAAA,KAAK,EAALA;AAAvB,KAAD,CAA1B;AACD;;AACD,SAAO,EAAP;AACD;;AAED,SAASJ,iBAAT,OAA0D;AAAA,MAA9BG,oBAA8B,QAA9BA,oBAA8B;AAAA,MAARC,KAAQ,QAARA,KAAQ;AACxD,MAAMC,0BAA0B,GAAGd,cAAc,CAACY,oBAAD,CAAjD;AACA,MAAMG,SAAS,GAAGjB,OAAO,CAACe,KAAD,CAAzB;AAEA,SAAO;AACLG,IAAAA,iCAAiC,EAAEF,0BAD9B;AAELG,IAAAA,+BAA+B,EAAEH,0BAF5B;AAGLI,IAAAA,gBAAgB,EAAEH;AAHb,GAAP;AAKD","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {fp64} from '@luma.gl/shadertools';\nconst {fp64ify, fp64ifyMatrix4} = fp64;\nimport {project, _memoize as memoize} from '@deck.gl/core';\n\nimport project64Shader from './project64.glsl';\n\nexport default {\n  name: 'project64',\n  dependencies: [project, fp64],\n  vs: project64Shader,\n  getUniforms\n};\n\n// TODO - this module should calculate the 64 bit uniforms\n// It is currently done by project to minimize duplicated work\n\nconst DEFAULT_MODULE_OPTIONS = {};\nconst getMemoizedUniforms = memoize(calculateUniforms);\n\nfunction getUniforms(opts = DEFAULT_MODULE_OPTIONS) {\n  if (opts.viewport) {\n    const {viewProjectionMatrix, scale} = opts.viewport;\n    // We only need to update fp64 uniforms if fp32 projection is being updated\n    return getMemoizedUniforms({viewProjectionMatrix, scale});\n  }\n  return {};\n}\n\nfunction calculateUniforms({viewProjectionMatrix, scale}) {\n  const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);\n  const scaleFP64 = fp64ify(scale);\n\n  return {\n    project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,\n    project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,\n    project64_uScale: scaleFP64\n  };\n}\n"],"file":"project64.js"}

package/dist/es5/index.js

@@ -7,43 +7,49 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "BrushingExtension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _brushing.default;
   }
 });
 Object.defineProperty(exports, "DataFilterExtension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _dataFilter.default;
   }
 });
 Object.defineProperty(exports, "Fp64Extension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fp.default;
   }
 });
 Object.defineProperty(exports, "PathStyleExtension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _pathStyle.default;
   }
 });
 Object.defineProperty(exports, "FillStyleExtension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fillStyle.default;
   }
 });
 Object.defineProperty(exports, "ClipExtension", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _clip.default;
   }
 });
+Object.defineProperty(exports, "MaskExtension", {
+  enumerable: true,
+  get: function get() {
+    return _mask.default;
+  }
+});
 Object.defineProperty(exports, "project64", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _project.default;
   }
 });
@@ -60,5 +66,7 @@ var _fillStyle = _interopRequireDefault(require("./fill-style/fill-style"));
 
 var _clip = _interopRequireDefault(require("./clip/clip"));
 
+var _mask = _interopRequireDefault(require("./mask/mask"));
+
 var _project = _interopRequireDefault(require("./fp64/project64"));
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA","sourcesContent":["export {default as BrushingExtension} from './brushing/brushing';\nexport {default as DataFilterExtension} from './data-filter/data-filter';\nexport {default as Fp64Extension} from './fp64/fp64';\nexport {default as PathStyleExtension} from './path-style/path-style';\nexport {default as FillStyleExtension} from './fill-style/fill-style';\nexport {default as ClipExtension} from './clip/clip';\n\n// Shader module\nexport {default as project64} from './fp64/project64';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA","sourcesContent":["export {default as BrushingExtension} from './brushing/brushing';\nexport {default as DataFilterExtension} from './data-filter/data-filter';\nexport {default as Fp64Extension} from './fp64/fp64';\nexport {default as PathStyleExtension} from './path-style/path-style';\nexport {default as FillStyleExtension} from './fill-style/fill-style';\nexport {default as ClipExtension} from './clip/clip';\nexport {default as MaskExtension} from './mask/mask';\n\n// Shader module\nexport {default as project64} from './fp64/project64';\n"],"file":"index.js"}

package/dist/es5/mask/mask.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _core = require("@deck.gl/core");
+
+var _shaderModule = _interopRequireDefault(require("./shader-module"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var defaultProps = {
+  maskEnabled: true
+};
+
+var MaskExtension = function (_LayerExtension) {
+  (0, _inherits2.default)(MaskExtension, _LayerExtension);
+
+  var _super = _createSuper(MaskExtension);
+
+  function MaskExtension() {
+    (0, _classCallCheck2.default)(this, MaskExtension);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(MaskExtension, [{
+    key: "getShaders",
+    value: function getShaders() {
+      var maskByInstance = ('instancePositions' in this.getAttributeManager().attributes);
+
+      if ('maskByInstance' in this.props) {
+        maskByInstance = this.props.maskByInstance;
+      }
+
+      this.state.maskByInstance = maskByInstance;
+      return {
+        modules: [_shaderModule.default]
+      };
+    }
+  }, {
+    key: "draw",
+    value: function draw(_ref) {
+      var uniforms = _ref.uniforms,
+          moduleParameters = _ref.moduleParameters;
+      uniforms.mask_maskByInstance = this.state.maskByInstance;
+      var maskBounds = moduleParameters.maskBounds;
+
+      if (maskBounds) {
+        var bl = this.projectPosition([maskBounds[0], maskBounds[1], 0]);
+        var tr = this.projectPosition([maskBounds[2], maskBounds[3], 0]);
+        uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];
+      }
+    }
+  }]);
+  return MaskExtension;
+}(_core.LayerExtension);
+
+exports.default = MaskExtension;
+MaskExtension.extensionName = 'MaskExtension';
+MaskExtension.defaultProps = defaultProps;
+//# sourceMappingURL=mask.js.map

package/dist/es5/mask/mask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/mask/mask.js"],"names":["defaultProps","maskEnabled","MaskExtension","maskByInstance","getAttributeManager","attributes","props","state","modules","mask","uniforms","moduleParameters","mask_maskByInstance","maskBounds","bl","projectPosition","tr","mask_bounds","LayerExtension","extensionName"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;;;AAEA,IAAMA,YAAY,GAAG;AACnBC,EAAAA,WAAW,EAAE;AADM,CAArB;;IAIqBC,a;;;;;;;;;;;;WACnB,sBAAa;AAEX,UAAIC,cAAc,IAAG,uBAAuB,KAAKC,mBAAL,GAA2BC,UAArD,CAAlB;;AAEA,UAAI,oBAAoB,KAAKC,KAA7B,EAAoC;AAClCH,QAAAA,cAAc,GAAG,KAAKG,KAAL,CAAWH,cAA5B;AACD;;AACD,WAAKI,KAAL,CAAWJ,cAAX,GAA4BA,cAA5B;AAEA,aAAO;AACLK,QAAAA,OAAO,EAAE,CAACC,qBAAD;AADJ,OAAP;AAGD;;;WAED,oBAAmC;AAAA,UAA7BC,QAA6B,QAA7BA,QAA6B;AAAA,UAAnBC,gBAAmB,QAAnBA,gBAAmB;AACjCD,MAAAA,QAAQ,CAACE,mBAAT,GAA+B,KAAKL,KAAL,CAAWJ,cAA1C;AACA,UAAOU,UAAP,GAAqBF,gBAArB,CAAOE,UAAP;;AACA,UAAIA,UAAJ,EAAgB;AACd,YAAMC,EAAE,GAAG,KAAKC,eAAL,CAAqB,CAACF,UAAU,CAAC,CAAD,CAAX,EAAgBA,UAAU,CAAC,CAAD,CAA1B,EAA+B,CAA/B,CAArB,CAAX;AACA,YAAMG,EAAE,GAAG,KAAKD,eAAL,CAAqB,CAACF,UAAU,CAAC,CAAD,CAAX,EAAgBA,UAAU,CAAC,CAAD,CAA1B,EAA+B,CAA/B,CAArB,CAAX;AACAH,QAAAA,QAAQ,CAACO,WAAT,GAAuB,CAACH,EAAE,CAAC,CAAD,CAAH,EAAQA,EAAE,CAAC,CAAD,CAAV,EAAeE,EAAE,CAAC,CAAD,CAAjB,EAAsBA,EAAE,CAAC,CAAD,CAAxB,CAAvB;AACD;AACF;;;EAvBwCE,oB;;;AA0B3ChB,aAAa,CAACiB,aAAd,GAA8B,eAA9B;AACAjB,aAAa,CAACF,YAAd,GAA6BA,YAA7B","sourcesContent":["import {LayerExtension} from '@deck.gl/core';\nimport mask from './shader-module';\n\nconst defaultProps = {\n  maskEnabled: true\n};\n\nexport default class MaskExtension extends LayerExtension {\n  getShaders() {\n    // Infer by geometry if 'maskByInstance' prop isn't explictly set\n    let maskByInstance = 'instancePositions' in this.getAttributeManager().attributes;\n    // Users can override by setting the `maskByInstance` prop\n    if ('maskByInstance' in this.props) {\n      maskByInstance = this.props.maskByInstance;\n    }\n    this.state.maskByInstance = maskByInstance;\n\n    return {\n      modules: [mask]\n    };\n  }\n\n  draw({uniforms, moduleParameters}) {\n    uniforms.mask_maskByInstance = this.state.maskByInstance;\n    const {maskBounds} = moduleParameters;\n    if (maskBounds) {\n      const bl = this.projectPosition([maskBounds[0], maskBounds[1], 0]);\n      const tr = this.projectPosition([maskBounds[2], maskBounds[3], 0]);\n      uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];\n    }\n  }\n}\n\nMaskExtension.extensionName = 'MaskExtension';\nMaskExtension.defaultProps = defaultProps;\n"],"file":"mask.js"}

package/dist/es5/mask/shader-module.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _core = require("@deck.gl/core");
+
+var vs = "\nuniform vec4 mask_bounds;\nuniform bool mask_maskByInstance;\nvec2 mask_getCoords(vec4 position) {\n  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);\n}\n";
+var fs = "\nuniform sampler2D mask_texture;\nuniform bool mask_enabled;\nbool mask_isInBounds(vec2 texCoords) {\n  if (!mask_enabled) {\n    return true;\n  }\n  vec4 maskColor = texture2D(mask_texture, texCoords);\n  return maskColor.a > 0.5;\n}\n";
+var inject = {
+  'vs:#decl': "\nvarying vec2 mask_texCoords;\n",
+  'vs:#main-end': "\n   vec4 mask_common_position;\n   if (mask_maskByInstance) {\n     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));\n   } else {\n     mask_common_position = geometry.position;\n   }\n   mask_texCoords = mask_getCoords(mask_common_position);\n",
+  'fs:#decl': "\nvarying vec2 mask_texCoords;\n",
+  'fs:#main-start': "\n  if (mask_enabled) {\n    bool mask = mask_isInBounds(mask_texCoords);\n\n    // Debug: show extent of render target\n    // gl_FragColor = vec4(mask_texCoords, 0.0, 1.0);\n    gl_FragColor = texture2D(mask_texture, mask_texCoords);\n\n    if (!mask) discard;\n  }\n"
+};
+
+var getMaskUniforms = function getMaskUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var uniforms = {};
+
+  if (opts.maskMap) {
+    uniforms.mask_enabled = opts.maskEnabled !== false;
+    uniforms.mask_texture = opts.maskMap;
+  }
+
+  return uniforms;
+};
+
+var _default = {
+  name: 'mask',
+  dependencies: [_core.project],
+  vs: vs,
+  fs: fs,
+  inject: inject,
+  getUniforms: getMaskUniforms
+};
+exports.default = _default;
+//# sourceMappingURL=shader-module.js.map

package/dist/es5/mask/shader-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/mask/shader-module.js"],"names":["vs","fs","inject","getMaskUniforms","opts","context","uniforms","maskMap","mask_enabled","maskEnabled","mask_texture","name","dependencies","project","getUniforms"],"mappings":";;;;;;;AAAA;;AAEA,IAAMA,EAAE,4LAAR;AAQA,IAAMC,EAAE,mPAAR;AAYA,IAAMC,MAAM,GAAG;AACb,gDADa;AAIb,oSAJa;AAab,gDAba;AAgBb;AAhBa,CAAf;;AA6BA,IAAMC,eAAe,GAAG,SAAlBA,eAAkB,GAA6B;AAAA,MAA5BC,IAA4B,uEAArB,EAAqB;AAAA,MAAjBC,OAAiB,uEAAP,EAAO;AACnD,MAAMC,QAAQ,GAAG,EAAjB;;AACA,MAAIF,IAAI,CAACG,OAAT,EAAkB;AAChBD,IAAAA,QAAQ,CAACE,YAAT,GAAwBJ,IAAI,CAACK,WAAL,KAAqB,KAA7C;AACAH,IAAAA,QAAQ,CAACI,YAAT,GAAwBN,IAAI,CAACG,OAA7B;AACD;;AACD,SAAOD,QAAP;AACD,CAPD;;eASe;AACbK,EAAAA,IAAI,EAAE,MADO;AAEbC,EAAAA,YAAY,EAAE,CAACC,aAAD,CAFD;AAGbb,EAAAA,EAAE,EAAFA,EAHa;AAIbC,EAAAA,EAAE,EAAFA,EAJa;AAKbC,EAAAA,MAAM,EAANA,MALa;AAMbY,EAAAA,WAAW,EAAEX;AANA,C","sourcesContent":["import {project} from '@deck.gl/core';\n\nconst vs = `\nuniform vec4 mask_bounds;\nuniform bool mask_maskByInstance;\nvec2 mask_getCoords(vec4 position) {\n  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);\n}\n`;\n\nconst fs = `\nuniform sampler2D mask_texture;\nuniform bool mask_enabled;\nbool mask_isInBounds(vec2 texCoords) {\n  if (!mask_enabled) {\n    return true;\n  }\n  vec4 maskColor = texture2D(mask_texture, texCoords);\n  return maskColor.a > 0.5;\n}\n`;\n\nconst inject = {\n  'vs:#decl': `\nvarying vec2 mask_texCoords;\n`,\n  'vs:#main-end': `\n   vec4 mask_common_position;\n   if (mask_maskByInstance) {\n     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));\n   } else {\n     mask_common_position = geometry.position;\n   }\n   mask_texCoords = mask_getCoords(mask_common_position);\n`,\n  'fs:#decl': `\nvarying vec2 mask_texCoords;\n`,\n  'fs:#main-start': `\n  if (mask_enabled) {\n    bool mask = mask_isInBounds(mask_texCoords);\n\n    // Debug: show extent of render target\n    // gl_FragColor = vec4(mask_texCoords, 0.0, 1.0);\n    gl_FragColor = texture2D(mask_texture, mask_texCoords);\n\n    if (!mask) discard;\n  }\n`\n};\n\nconst getMaskUniforms = (opts = {}, context = {}) => {\n  const uniforms = {};\n  if (opts.maskMap) {\n    uniforms.mask_enabled = opts.maskEnabled !== false;\n    uniforms.mask_texture = opts.maskMap;\n  }\n  return uniforms;\n};\n\nexport default {\n  name: 'mask',\n  dependencies: [project],\n  vs,\n  fs,\n  inject,\n  getUniforms: getMaskUniforms\n};\n"],"file":"shader-module.js"}

package/dist/es5/path-style/path-style.js

@@ -1,17 +1,33 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _core = require("@deck.gl/core");
 
 var _shaders = require("./shaders.glsl");
 
 var _vec = require("gl-matrix/vec3");
 
-const defaultProps = {
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var defaultProps = {
   getDashArray: {
     type: 'accessor',
     value: [0, 0]
@@ -24,117 +40,133 @@ const defaultProps = {
   dashGapPickable: false
 };
 
-class PathStyleExtension extends _core.LayerExtension {
-  constructor({
-    dash = false,
-    offset = false,
-    highPrecisionDash = false
-  } = {}) {
-    super({
-      dash: dash || highPrecisionDash,
-      offset,
-      highPrecisionDash
-    });
-  }
-
-  isEnabled(layer) {
-    return layer.state.pathTesselator;
-  }
-
-  getShaders(extension) {
-    if (!extension.isEnabled(this)) {
-      return null;
-    }
+var PathStyleExtension = function (_LayerExtension) {
+  (0, _inherits2.default)(PathStyleExtension, _LayerExtension);
 
-    let result = {};
+  var _super = _createSuper(PathStyleExtension);
 
-    if (extension.opts.dash) {
-      result = (0, _core._mergeShaders)(result, _shaders.dashShaders);
-    }
+  function PathStyleExtension() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$dash = _ref.dash,
+        dash = _ref$dash === void 0 ? false : _ref$dash,
+        _ref$offset = _ref.offset,
+        offset = _ref$offset === void 0 ? false : _ref$offset,
+        _ref$highPrecisionDas = _ref.highPrecisionDash,
+        highPrecisionDash = _ref$highPrecisionDas === void 0 ? false : _ref$highPrecisionDas;
 
-    if (extension.opts.offset) {
-      result = (0, _core._mergeShaders)(result, _shaders.offsetShaders);
-    }
-
-    return result;
+    (0, _classCallCheck2.default)(this, PathStyleExtension);
+    return _super.call(this, {
+      dash: dash || highPrecisionDash,
+      offset: offset,
+      highPrecisionDash: highPrecisionDash
+    });
   }
 
-  initializeState(context, extension) {
-    const attributeManager = this.getAttributeManager();
-
-    if (!attributeManager || !extension.isEnabled(this)) {
-      return;
+  (0, _createClass2.default)(PathStyleExtension, [{
+    key: "isEnabled",
+    value: function isEnabled(layer) {
+      return layer.state.pathTesselator;
     }
+  }, {
+    key: "getShaders",
+    value: function getShaders(extension) {
+      if (!extension.isEnabled(this)) {
+        return null;
+      }
 
-    extension.enabled = true;
+      var result = {};
 
-    if (extension.opts.dash) {
-      attributeManager.addInstanced({
-        instanceDashArrays: {
-          size: 2,
-          accessor: 'getDashArray'
-        }
-      });
-    }
+      if (extension.opts.dash) {
+        result = (0, _core._mergeShaders)(result, _shaders.dashShaders);
+      }
 
-    if (extension.opts.highPrecisionDash) {
-      attributeManager.addInstanced({
-        instanceDashOffsets: {
-          size: 1,
-          accessor: 'getPath',
-          transform: extension.getDashOffsets.bind(this)
-        }
-      });
-    }
+      if (extension.opts.offset) {
+        result = (0, _core._mergeShaders)(result, _shaders.offsetShaders);
+      }
 
-    if (extension.opts.offset) {
-      attributeManager.addInstanced({
-        instanceOffsets: {
-          size: 1,
-          accessor: 'getOffset'
-        }
-      });
+      return result;
     }
-  }
+  }, {
+    key: "initializeState",
+    value: function initializeState(context, extension) {
+      var attributeManager = this.getAttributeManager();
 
-  updateState(params, extension) {
-    if (!extension.isEnabled(this)) {
-      return;
-    }
+      if (!attributeManager || !extension.isEnabled(this)) {
+        return;
+      }
 
-    const uniforms = {};
+      extension.enabled = true;
 
-    if (extension.opts.dash) {
-      uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
-      uniforms.dashGapPickable = Boolean(this.props.dashGapPickable);
-    }
+      if (extension.opts.dash) {
+        attributeManager.addInstanced({
+          instanceDashArrays: {
+            size: 2,
+            accessor: 'getDashArray'
+          }
+        });
+      }
 
-    this.state.model.setUniforms(uniforms);
-  }
+      if (extension.opts.highPrecisionDash) {
+        attributeManager.addInstanced({
+          instanceDashOffsets: {
+            size: 1,
+            accessor: 'getPath',
+            transform: extension.getDashOffsets.bind(this)
+          }
+        });
+      }
 
-  getDashOffsets(path) {
-    const result = [0];
-    const positionSize = this.props.positionFormat === 'XY' ? 2 : 3;
-    const isNested = Array.isArray(path[0]);
-    const geometrySize = isNested ? path.length : path.length / positionSize;
-    let p;
-    let prevP;
+      if (extension.opts.offset) {
+        attributeManager.addInstanced({
+          instanceOffsets: {
+            size: 1,
+            accessor: 'getOffset'
+          }
+        });
+      }
+    }
+  }, {
+    key: "updateState",
+    value: function updateState(params, extension) {
+      if (!extension.isEnabled(this)) {
+        return;
+      }
 
-    for (let i = 0; i < geometrySize - 1; i++) {
-      p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
-      p = this.projectPosition(p);
+      var uniforms = {};
 
-      if (i > 0) {
-        result[i] = result[i - 1] + (0, _vec.dist)(prevP, p);
+      if (extension.opts.dash) {
+        uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
+        uniforms.dashGapPickable = Boolean(this.props.dashGapPickable);
       }
 
-      prevP = p;
+      this.state.model.setUniforms(uniforms);
     }
+  }, {
+    key: "getDashOffsets",
+    value: function getDashOffsets(path) {
+      var result = [0];
+      var positionSize = this.props.positionFormat === 'XY' ? 2 : 3;
+      var isNested = Array.isArray(path[0]);
+      var geometrySize = isNested ? path.length : path.length / positionSize;
+      var p;
+      var prevP;
+
+      for (var i = 0; i < geometrySize - 1; i++) {
+        p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
+        p = this.projectPosition(p);
+
+        if (i > 0) {
+          result[i] = result[i - 1] + (0, _vec.dist)(prevP, p);
+        }
 
-    return result;
-  }
+        prevP = p;
+      }
 
-}
+      return result;
+    }
+  }]);
+  return PathStyleExtension;
+}(_core.LayerExtension);
 
 exports.default = PathStyleExtension;
 PathStyleExtension.extensionName = 'PathStyleExtension';