Showing 256 of 374 total issues
Function 6
has 56 lines of code (exceeds 25 allowed). Consider refactoring. Open
},{}],6:[function(require,module,exports){
var hasOwn = Object.prototype.hasOwnProperty;
var toString = Object.prototype.toString;
var undefined;
Function memoization
has 56 lines of code (exceeds 25 allowed). Consider refactoring. Open
ko.memoization = (function () {
var memos = {};
function randomMax8HexChars() {
return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
Function init
has 55 lines of code (exceeds 25 allowed). Consider refactoring. Open
'init': function (element, valueAccessor, allBindings) {
var checkedValue = ko.pureComputed(function() {
// Treat "value" like "checkedValue" when it is included with "checked" binding
if (allBindings['has']('checkedValue')) {
return ko.utils.unwrapObservable(allBindings.get('checkedValue'));
Function compareSmallArrayToBigArray
has 53 lines of code (exceeds 25 allowed). Consider refactoring. Open
function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options) {
var myMin = Math.min,
myMax = Math.max,
editDistanceMatrix = [],
smlIndex, smlIndexMax = smlArray.length,
Function e
has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring. Open
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function create
has 51 lines of code (exceeds 25 allowed). Consider refactoring. Open
Request.prototype.create = function(){
var xhr = this.xhr = new XMLHttpRequest({ agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR });
var self = this;
try {
Function checkBadness
has 51 lines of code (exceeds 25 allowed). Consider refactoring. Open
function checkBadness() {
var b, b1, bad, big, bw, count, h, x, y;
bad = bw = count = 0;
// Blocks of same colour.
Function define
has 50 lines of code (exceeds 25 allowed). Consider refactoring. Open
Function_prototype.define = function define(prototype, mixins) {
/// <summary>Define members on the prototype of the given function with the custom methods and fields specified in the prototype parameter.</summary>
/// <param name="prototype" type="Function || Plain Object">{} or function(prototype, ctor) {}<br/>A custom object with the methods or properties to be added on Extendee.prototype</param>
/// <param name="mixins" type="Function || Plain Object" optional="true" parameterArray="true">Specify one ore more mixins to be added to this function's prototype. <br/>A Mixin is either a function which returns a plain object, or a plan object in itself. It contains method or properties to be added to this function's prototype</param>
var constructor = this;
Function 54
has 50 lines of code (exceeds 25 allowed). Consider refactoring. Open
},{}],54:[function(require,module,exports){
(function(g) {
var FORMAT_RE = /({+)([^:{\|}]+)(\|([^:}]+))?(:(-?\d*)([ij]?))?(}+)/g,
defined = function(x) { return typeof x !== 'undefined' },
format = function() {
Function show
has 50 lines of code (exceeds 25 allowed). Consider refactoring. Open
Tooltip.prototype.show = function () {
var e = $.Event('show.bs.' + this.type)
if (this.hasContent() && this.enabled) {
this.$element.trigger(e)
Function jqueryTmplTemplateEngine
has 48 lines of code (exceeds 25 allowed). Consider refactoring. Open
ko.jqueryTmplTemplateEngine = function () {
// Detect which version of jquery-tmpl you're using. Unfortunately jquery-tmpl
// doesn't expose a version number, so we have to infer it.
// Note that as of Knockout 1.3, we only support jQuery.tmpl 1.0.0pre and later,
// which KO internally refers to as version "2", so older versions are no longer detected.
Function 27
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
},{"../transport":21,"component-inherit":28,"debug":9,"engine.io-parser":29,"parseqs":39,"ws":41}],27:[function(require,module,exports){
// browser shim for xmlhttprequest module
var hasCORS = require('has-cors');
module.exports = function(opts) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function 45
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
},{}],45:[function(require,module,exports){
/**
* HOP ref.
*/
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function templateRewriting
has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open
ko.templateRewriting = (function () {
var memoizeDataBindingAttributeSyntaxRegex = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi;
var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
function validateDataBindValuesForRewriting(keyValueArray) {
Function encodePayloadAsArrayBuffer
has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open
exports.encodePayloadAsArrayBuffer = function(packets, callback) {
if (!packets.length) {
return callback(new ArrayBuffer(0));
}
Function 5
has 46 lines of code (exceeds 25 allowed). Consider refactoring. Open
},{}],5:[function(require,module,exports){
function Elapsed (from, to) {
this.from = from;
this.to = to || new Date();
if (!(this.from instanceof Date && this.to instanceof Date)) return;
Function decodeSymbol
has 46 lines of code (exceeds 25 allowed). Consider refactoring. Open
function decodeSymbol() {
var byte1;
var byte2;
var byte3;
var byte4;
Function bindingContext
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
ko.bindingContext = function(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback) {
// The binding context object includes static properties for the current, parent, and root view models.
// If a view model is actually stored in an observable, the corresponding binding context object, and
// any child contexts, must be updated when the view model is changed.
Function Socket
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
function Socket(uri, opts){
if (!(this instanceof Socket)) return new Socket(uri, opts);
opts = opts || {};
Function decodeString
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
function decodeString(str) {
var p = {};
var i = 0;
// look up type