@antv/l7-renderer 2.21.0 → 2.21.2

package/es/device/utils/HashMap.js

@@ -1,153 +1,86 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-// Jenkins One-at-a-Time hash from http://www.burtleburtle.net/bob/hash/doobs.html
-export function hashCodeNumberUpdate(hash) {
-  var v = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+// src/device/utils/HashMap.ts
+function hashCodeNumberUpdate(hash, v = 0) {
   hash += v;
   hash += hash << 10;
   hash += hash >>> 6;
   return hash >>> 0;
 }
-export function hashCodeNumberFinish(hash) {
+function hashCodeNumberFinish(hash) {
   hash += hash << 3;
   hash ^= hash >>> 11;
   hash += hash << 15;
   return hash >>> 0;
 }
-
-// Pass this as a hash function to use a one-bucket HashMap (equivalent to linear search in an array),
-// which can be efficient for small numbers of items.
-export function nullHashFunc() {
+function nullHashFunc() {
   return 0;
 }
-var HashBucket = /*#__PURE__*/_createClass(function HashBucket() {
-  _classCallCheck(this, HashBucket);
-  _defineProperty(this, "keys", []);
-  _defineProperty(this, "values", []);
-});
-export var HashMap = /*#__PURE__*/function () {
-  function HashMap(keyEqualFunc, keyHashFunc) {
-    _classCallCheck(this, HashMap);
-    _defineProperty(this, "buckets", new Map());
+var HashBucket = class {
+  constructor() {
+    this.keys = [];
+    this.values = [];
+  }
+};
+var HashMap = class {
+  constructor(keyEqualFunc, keyHashFunc) {
     this.keyEqualFunc = keyEqualFunc;
     this.keyHashFunc = keyHashFunc;
+    this.buckets = /* @__PURE__ */ new Map();
+  }
+  findBucketIndex(bucket, k) {
+    for (let i = 0; i < bucket.keys.length; i++)
+      if (this.keyEqualFunc(k, bucket.keys[i]))
+        return i;
+    return -1;
+  }
+  findBucket(k) {
+    const bw = this.keyHashFunc(k);
+    return this.buckets.get(bw);
+  }
+  get(k) {
+    const bucket = this.findBucket(k);
+    if (bucket === void 0)
+      return null;
+    const bi = this.findBucketIndex(bucket, k);
+    if (bi < 0)
+      return null;
+    return bucket.values[bi];
+  }
+  add(k, v) {
+    const bw = this.keyHashFunc(k);
+    if (this.buckets.get(bw) === void 0)
+      this.buckets.set(bw, new HashBucket());
+    const bucket = this.buckets.get(bw);
+    bucket.keys.push(k);
+    bucket.values.push(v);
+  }
+  delete(k) {
+    const bucket = this.findBucket(k);
+    if (bucket === void 0)
+      return;
+    const bi = this.findBucketIndex(bucket, k);
+    if (bi === -1)
+      return;
+    bucket.keys.splice(bi, 1);
+    bucket.values.splice(bi, 1);
+  }
+  clear() {
+    this.buckets.clear();
+  }
+  size() {
+    let acc = 0;
+    for (const bucket of this.buckets.values())
+      acc += bucket.values.length;
+    return acc;
+  }
+  *values() {
+    for (const bucket of this.buckets.values())
+      for (let j = bucket.values.length - 1; j >= 0; j--)
+        yield bucket.values[j];
   }
-  _createClass(HashMap, [{
-    key: "findBucketIndex",
-    value: function findBucketIndex(bucket, k) {
-      for (var i = 0; i < bucket.keys.length; i++) if (this.keyEqualFunc(k, bucket.keys[i])) return i;
-      return -1;
-    }
-  }, {
-    key: "findBucket",
-    value: function findBucket(k) {
-      var bw = this.keyHashFunc(k);
-      return this.buckets.get(bw);
-    }
-  }, {
-    key: "get",
-    value: function get(k) {
-      var bucket = this.findBucket(k);
-      if (bucket === undefined) return null;
-      var bi = this.findBucketIndex(bucket, k);
-      if (bi < 0) return null;
-      return bucket.values[bi];
-    }
-  }, {
-    key: "add",
-    value: function add(k, v) {
-      var bw = this.keyHashFunc(k);
-      if (this.buckets.get(bw) === undefined) this.buckets.set(bw, new HashBucket());
-      var bucket = this.buckets.get(bw);
-      bucket.keys.push(k);
-      bucket.values.push(v);
-    }
-  }, {
-    key: "delete",
-    value: function _delete(k) {
-      var bucket = this.findBucket(k);
-      if (bucket === undefined) return;
-      var bi = this.findBucketIndex(bucket, k);
-      if (bi === -1) return;
-      bucket.keys.splice(bi, 1);
-      bucket.values.splice(bi, 1);
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.buckets.clear();
-    }
-  }, {
-    key: "size",
-    value: function size() {
-      var acc = 0;
-      var _iterator = _createForOfIteratorHelper(this.buckets.values()),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var bucket = _step.value;
-          acc += bucket.values.length;
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return acc;
-    }
-  }, {
-    key: "values",
-    value: /*#__PURE__*/_regeneratorRuntime.mark(function values() {
-      var _iterator2, _step2, bucket, j;
-      return _regeneratorRuntime.wrap(function values$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _iterator2 = _createForOfIteratorHelper(this.buckets.values());
-            _context.prev = 1;
-            _iterator2.s();
-          case 3:
-            if ((_step2 = _iterator2.n()).done) {
-              _context.next = 14;
-              break;
-            }
-            bucket = _step2.value;
-            j = bucket.values.length - 1;
-          case 6:
-            if (!(j >= 0)) {
-              _context.next = 12;
-              break;
-            }
-            _context.next = 9;
-            return bucket.values[j];
-          case 9:
-            j--;
-            _context.next = 6;
-            break;
-          case 12:
-            _context.next = 3;
-            break;
-          case 14:
-            _context.next = 19;
-            break;
-          case 16:
-            _context.prev = 16;
-            _context.t0 = _context["catch"](1);
-            _iterator2.e(_context.t0);
-          case 19:
-            _context.prev = 19;
-            _iterator2.f();
-            return _context.finish(19);
-          case 22:
-          case "end":
-            return _context.stop();
-        }
-      }, values, this, [[1, 16, 19, 22]]);
-    })
-  }]);
-  return HashMap;
-}();
+};
+export {
+  HashMap,
+  hashCodeNumberFinish,
+  hashCodeNumberUpdate,
+  nullHashFunc
+};

package/es/device/utils/pipeline.js

@@ -1 +1,6 @@
-export function pipelineEquals() {}
+// src/device/utils/pipeline.ts
+function pipelineEquals() {
+}
+export {
+  pipelineEquals
+};

package/es/device/utils/typedarray.js

@@ -1,34 +1,33 @@
+// src/device/utils/typedarray.ts
 var dtypes = {
-  '[object Int8Array]': 5120,
-  '[object Int16Array]': 5122,
-  '[object Int32Array]': 5124,
-  '[object Uint8Array]': 5121,
-  '[object Uint8ClampedArray]': 5121,
-  '[object Uint16Array]': 5123,
-  '[object Uint32Array]': 5125,
-  '[object Float32Array]': 5126,
-  '[object Float64Array]': 5121,
-  '[object ArrayBuffer]': 5121
+  "[object Int8Array]": 5120,
+  "[object Int16Array]": 5122,
+  "[object Int32Array]": 5124,
+  "[object Uint8Array]": 5121,
+  "[object Uint8ClampedArray]": 5121,
+  "[object Uint16Array]": 5123,
+  "[object Uint32Array]": 5125,
+  "[object Float32Array]": 5126,
+  "[object Float64Array]": 5121,
+  "[object ArrayBuffer]": 5121
 };
-// eslint-disable-next-line
-export function isTypedArray(x) {
+function isTypedArray(x) {
   return Object.prototype.toString.call(x) in dtypes;
 }
-
-/**
- * WebGPU does not support RGB texture, so we need to convert RGB to RGBA
- * @see https://github.com/antvis/L7/pull/2262
- */
-export function extend3ChannelsTo4(array, valueToInsert) {
-  var originalLength = array.length;
-  var insertCount = Math.ceil(originalLength / 3);
-  var newLength = originalLength + insertCount;
-  var newArray = new Float32Array(newLength);
-  for (var i = 0; i < newLength; i += 4) {
+function extend3ChannelsTo4(array, valueToInsert) {
+  const originalLength = array.length;
+  const insertCount = Math.ceil(originalLength / 3);
+  const newLength = originalLength + insertCount;
+  const newArray = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i += 4) {
     newArray[i] = array[i / 4 * 3];
     newArray[i + 1] = array[i / 4 * 3 + 1];
     newArray[i + 2] = array[i / 4 * 3 + 2];
     newArray[i + 3] = valueToInsert;
   }
   return newArray;
-}
+}
+export {
+  extend3ChannelsTo4,
+  isTypedArray
+};

package/es/device/utils/webgl.js

@@ -1,9 +1,10 @@
-// @see https://github.com/visgl/luma.gl/blob/30a1039573576d73641de7c1ba222e8992eb526e/modules/gltools/src/utils/webgl-checks.ts#L22
-export function isWebGL2(gl) {
-  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
+// src/device/utils/webgl.ts
+function isWebGL2(gl) {
+  if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
     return true;
   }
-  // Look for debug contexts, headless gl etc
-  // @ts-ignore
   return Boolean(gl && gl._version === 2);
-}
+}
+export {
+  isWebGL2
+};

package/es/index.js

@@ -1,6 +1,7 @@
-/**
- *
- */
+// src/index.ts
 import DeviceRendererService from "./device";
 import ReglRendererService from "./regl";
-export { DeviceRendererService, ReglRendererService };
+export {
+  DeviceRendererService,
+  ReglRendererService
+};

package/es/regl/ReglAttribute.js

@@ -1,17 +1,7 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-/**
- * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#attributes
- */
-var ReglAttribute = /*#__PURE__*/function () {
-  function ReglAttribute(gl, options) {
-    _classCallCheck(this, ReglAttribute);
-    var buffer = options.buffer,
-      offset = options.offset,
-      stride = options.stride,
-      normalized = options.normalized,
-      size = options.size,
-      divisor = options.divisor;
+// src/regl/ReglAttribute.ts
+var ReglAttribute = class {
+  constructor(gl, options) {
+    const { buffer, offset, stride, normalized, size, divisor } = options;
     this.buffer = buffer;
     this.attribute = {
       buffer: buffer.get(),
@@ -24,22 +14,16 @@ var ReglAttribute = /*#__PURE__*/function () {
       this.attribute.size = size;
     }
   }
-  _createClass(ReglAttribute, [{
-    key: "get",
-    value: function get() {
-      return this.attribute;
-    }
-  }, {
-    key: "updateBuffer",
-    value: function updateBuffer(options) {
-      this.buffer.subData(options);
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.buffer.destroy();
-    }
-  }]);
-  return ReglAttribute;
-}();
-export { ReglAttribute as default };
+  get() {
+    return this.attribute;
+  }
+  updateBuffer(options) {
+    this.buffer.subData(options);
+  }
+  destroy() {
+    this.buffer.destroy();
+  }
+};
+export {
+  ReglAttribute as default
+};

package/es/regl/ReglBuffer.js

@@ -1,48 +1,33 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { gl } from '@antv/l7-core';
+// src/regl/ReglBuffer.ts
+import { gl } from "@antv/l7-core";
 import { dataTypeMap, usageMap } from "./constants";
-
-/**
- * adaptor for regl.Buffer
- * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#buffers
- */
-var ReglBuffer = /*#__PURE__*/function () {
-  function ReglBuffer(reGl, options) {
-    _classCallCheck(this, ReglBuffer);
-    _defineProperty(this, "isDestroyed", false);
-    var data = options.data,
-      usage = options.usage,
-      type = options.type;
+var ReglBuffer = class {
+  constructor(reGl, options) {
+    this.isDestroyed = false;
+    const { data, usage, type } = options;
     this.buffer = reGl.buffer({
-      data: data,
+      data,
       usage: usageMap[usage || gl.STATIC_DRAW],
       type: dataTypeMap[type || gl.UNSIGNED_BYTE]
       // length: 0,
     });
   }
-  _createClass(ReglBuffer, [{
-    key: "get",
-    value: function get() {
-      return this.buffer;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      if (!this.isDestroyed) {
-        this.buffer.destroy();
-      }
-      this.isDestroyed = true;
-    }
-  }, {
-    key: "subData",
-    value: function subData(_ref) {
-      var data = _ref.data,
-        offset = _ref.offset;
-      this.buffer.subdata(data, offset);
+  get() {
+    return this.buffer;
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      this.buffer.destroy();
     }
-  }]);
-  return ReglBuffer;
-}();
-export { ReglBuffer as default };
+    this.isDestroyed = true;
+  }
+  subData({
+    data,
+    offset
+  }) {
+    this.buffer.subdata(data, offset);
+  }
+};
+export {
+  ReglBuffer as default
+};

package/es/regl/ReglElements.js

@@ -1,42 +1,27 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import { gl } from '@antv/l7-core';
+// src/regl/ReglElements.ts
+import { gl } from "@antv/l7-core";
 import { dataTypeMap, usageMap } from "./constants";
-
-/**
- * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#elements
- */
-var ReglElements = /*#__PURE__*/function () {
-  function ReglElements(reGl, options) {
-    _classCallCheck(this, ReglElements);
-    var data = options.data,
-      usage = options.usage,
-      type = options.type,
-      count = options.count;
+var ReglElements = class {
+  constructor(reGl, options) {
+    const { data, usage, type, count } = options;
     this.elements = reGl.elements({
-      data: data,
+      data,
       usage: usageMap[usage || gl.STATIC_DRAW],
       type: dataTypeMap[type || gl.UNSIGNED_BYTE],
-      count: count
+      count
     });
   }
-  _createClass(ReglElements, [{
-    key: "get",
-    value: function get() {
-      return this.elements;
-    }
-  }, {
-    key: "subData",
-    value: function subData(_ref) {
-      var data = _ref.data;
-      this.elements.subdata(data);
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      // this.elements.destroy();
-    }
-  }]);
-  return ReglElements;
-}();
-export { ReglElements as default };
+  get() {
+    return this.elements;
+  }
+  subData({
+    data
+  }) {
+    this.elements.subdata(data);
+  }
+  destroy() {
+  }
+};
+export {
+  ReglElements as default
+};

package/es/regl/ReglFramebuffer.js

@@ -1,51 +1,31 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-/**
- * adaptor for regl.Framebuffer
- * @see https://github.com/regl-project/regl/blob/gh-pages/API.md#framebuffers
- */
-var ReglFramebuffer = /*#__PURE__*/function () {
-  function ReglFramebuffer(reGl, options) {
-    _classCallCheck(this, ReglFramebuffer);
-    var width = options.width,
-      height = options.height,
-      color = options.color,
-      colors = options.colors;
-    var framebufferOptions = {
-      width: width,
-      height: height
+// src/regl/ReglFramebuffer.ts
+var ReglFramebuffer = class {
+  constructor(reGl, options) {
+    const { width, height, color, colors } = options;
+    const framebufferOptions = {
+      width,
+      height
     };
     if (Array.isArray(colors)) {
-      framebufferOptions.colors = colors.map(function (c) {
-        return c.get();
-      });
+      framebufferOptions.colors = colors.map(
+        (c) => c.get()
+      );
     }
-    if (color && typeof color !== 'boolean') {
+    if (color && typeof color !== "boolean") {
       framebufferOptions.color = color.get();
     }
-
-    // TODO: depth & stencil
-
     this.framebuffer = reGl.framebuffer(framebufferOptions);
   }
-  _createClass(ReglFramebuffer, [{
-    key: "get",
-    value: function get() {
-      return this.framebuffer;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.framebuffer.destroy();
-    }
-  }, {
-    key: "resize",
-    value: function resize(_ref) {
-      var width = _ref.width,
-        height = _ref.height;
-      this.framebuffer.resize(width, height);
-    }
-  }]);
-  return ReglFramebuffer;
-}();
-export { ReglFramebuffer as default };
+  get() {
+    return this.framebuffer;
+  }
+  destroy() {
+    this.framebuffer.destroy();
+  }
+  resize({ width, height }) {
+    this.framebuffer.resize(width, height);
+  }
+};
+export {
+  ReglFramebuffer as default
+};