Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
@antv/g-ecs
Advanced tools
@antv/g-ecs - npm Package Compare versions
Comparing version 1.0.0-alpha.10 to 1.0.0-alpha.11
| import 'reflect-metadata'; | ||
| import { injectable, transient, inject, singleton, Module, decorate } from 'mana-syringe'; | ||
| import { EventEmitter } from 'eventemitter3'; | ||
| import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck'; | ||
| import _createClass from '@babel/runtime/helpers/esm/createClass'; | ||
| import _inherits from '@babel/runtime/helpers/esm/inherits'; | ||
| import _createSuper from '@babel/runtime/helpers/esm/createSuper'; | ||
| import _createForOfIteratorHelper from '@babel/runtime/helpers/esm/createForOfIteratorHelper'; | ||
| import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray'; | ||
| function _classCallCheck(instance, Constructor) { | ||
| if (!(instance instanceof Constructor)) { | ||
| throw new TypeError("Cannot call a class as a function"); | ||
| } | ||
| } | ||
| function _defineProperties(target, props) { | ||
| for (var i = 0; i < props.length; i++) { | ||
| var descriptor = props[i]; | ||
| descriptor.enumerable = descriptor.enumerable || false; | ||
| descriptor.configurable = true; | ||
| if ("value" in descriptor) descriptor.writable = true; | ||
| Object.defineProperty(target, descriptor.key, descriptor); | ||
| } | ||
| } | ||
| function _createClass(Constructor, protoProps, staticProps) { | ||
| if (protoProps) _defineProperties(Constructor.prototype, protoProps); | ||
| if (staticProps) _defineProperties(Constructor, staticProps); | ||
| return Constructor; | ||
| } | ||
| function _inherits(subClass, superClass) { | ||
| if (typeof superClass !== "function" && superClass !== null) { | ||
| throw new TypeError("Super expression must either be null or a function"); | ||
| } | ||
| subClass.prototype = Object.create(superClass && superClass.prototype, { | ||
| constructor: { | ||
| value: subClass, | ||
| writable: true, | ||
| configurable: true | ||
| } | ||
| }); | ||
| if (superClass) _setPrototypeOf(subClass, superClass); | ||
| } | ||
| function _getPrototypeOf(o) { | ||
| _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { | ||
| return o.__proto__ || Object.getPrototypeOf(o); | ||
| }; | ||
| return _getPrototypeOf(o); | ||
| } | ||
| function _setPrototypeOf(o, p) { | ||
| _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { | ||
| o.__proto__ = p; | ||
| return o; | ||
| }; | ||
| return _setPrototypeOf(o, p); | ||
| } | ||
| 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; | ||
| } | ||
| } | ||
| function _assertThisInitialized(self) { | ||
| if (self === void 0) { | ||
| throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); | ||
| } | ||
| return self; | ||
| } | ||
| function _possibleConstructorReturn(self, call) { | ||
| if (call && (typeof call === "object" || typeof call === "function")) { | ||
| return call; | ||
| } else if (call !== void 0) { | ||
| throw new TypeError("Derived constructors may only return object or undefined"); | ||
| } | ||
| return _assertThisInitialized(self); | ||
| } | ||
| function _createSuper(Derived) { | ||
| var hasNativeReflectConstruct = _isNativeReflectConstruct(); | ||
| return function _createSuperInternal() { | ||
| var Super = _getPrototypeOf(Derived), | ||
| result; | ||
| if (hasNativeReflectConstruct) { | ||
| var NewTarget = _getPrototypeOf(this).constructor; | ||
| result = Reflect.construct(Super, arguments, NewTarget); | ||
| } else { | ||
| result = Super.apply(this, arguments); | ||
| } | ||
| return _possibleConstructorReturn(this, result); | ||
| }; | ||
| } | ||
| function _toConsumableArray(arr) { | ||
| return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); | ||
| } | ||
| function _arrayWithoutHoles(arr) { | ||
| if (Array.isArray(arr)) return _arrayLikeToArray(arr); | ||
| } | ||
| function _iterableToArray(iter) { | ||
| if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); | ||
| } | ||
| 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; | ||
| } | ||
| function _nonIterableSpread() { | ||
| throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); | ||
| } | ||
| 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 () {}; | ||
| return { | ||
| s: F, | ||
| n: function () { | ||
| if (i >= o.length) return { | ||
| done: true | ||
| }; | ||
| return { | ||
| done: false, | ||
| value: o[i++] | ||
| }; | ||
| }, | ||
| e: function (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 () { | ||
| it = it.call(o); | ||
| }, | ||
| n: function () { | ||
| var step = it.next(); | ||
| normalCompletion = step.done; | ||
| return step; | ||
| }, | ||
| e: function (e) { | ||
| didErr = true; | ||
| err = e; | ||
| }, | ||
| f: function () { | ||
| try { | ||
| if (!normalCompletion && it.return != null) it.return(); | ||
| } finally { | ||
| if (didErr) throw err; | ||
| } | ||
| } | ||
| }; | ||
| } | ||
| /*! ***************************************************************************** | ||
@@ -199,0 +12,0 @@ Copyright (c) Microsoft Corporation. |
| { | ||
| "name": "@antv/g-ecs", | ||
| "version": "1.0.0-alpha.10", | ||
| "version": "1.0.0-alpha.11", | ||
| "description": "A simple ECS implement", | ||
@@ -40,2 +40,3 @@ "main": "dist/index.js", | ||
| "dependencies": { | ||
| "@babel/runtime": "^7.16.0", | ||
| "eventemitter3": "^4.0.0", | ||
@@ -45,3 +46,3 @@ "mana-syringe": "^0.1.0", | ||
| }, | ||
| "gitHead": "04974923388e3c1e3c47d591c251380058372376" | ||
| "gitHead": "c01101beb86f98aaa569f97c678c909d4f3faaa3" | ||
| } |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-7.41%
61597
- Dependency count
- increased by33.33%
4
- Lines of code
- decreased by-8.34%
1693
Dependency changes
+ Added@babel/runtime@^7.16.0
+ Added@babel/runtime@7.26.0(transitive)
+ Addedregenerator-runtime@0.14.1(transitive)