michielbdejong/solid-ui

View on GitHub

Showing 270 of 337 total issues

Function matrixForQuery has 185 lines of code (exceeds 25 allowed). Consider refactoring.
Open

module.exports.matrixForQuery = function (
  dom,
  query,
  vx,
  vy,
Severity: Major
Found in src/matrix.js - About 7 hrs to fix

    Function newThingUI has 184 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function newThingUI (createContext, dataBrowserContext, thePanes) {
      if (!thePanes) throw new Error('@@ newThingUI: update API') // phase out
      const dom = createContext.dom
      const div = createContext.div
      if (createContext.me && !createContext.me.uri) {
    Severity: Major
    Found in src/create.js - About 7 hrs to fix

      Function exports has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.
      Open

      module.exports = function (dom, kb, subject, messageStore, options) {
        kb = kb || UI.store
        messageStore = messageStore.doc() // No hash
        var ns = UI.ns
        var WF = $rdf.Namespace('http://www.w3.org/2005/01/wf/flow#')
      Severity: Minor
      Found in src/messageArea.js - About 7 hrs to fix

      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 exports has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.
      Open

      module.exports = function (dom, kb, subject, messageStore, options) {
        kb = kb || UI.store
        messageStore = messageStore.doc() // No hash
        var ns = UI.ns
        var WF = $rdf.Namespace('http://www.w3.org/2005/01/wf/flow#')
      Severity: Minor
      Found in src/chat/thread.js - About 7 hrs to fix

      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 buildCheckboxForm has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring.
      Open

      function buildCheckboxForm (dom, kb, lab, del, ins, form, store, tristate) {
        // 20190115
        var box = dom.createElement('div')
        var tx = dom.createTextNode(lab)
        var editable = UI.store.updater.editable(store.uri)
      Severity: Minor
      Found in src/widgets/forms.js - About 7 hrs to fix

      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

      File peoplePicker.js has 456 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      /**
       *
       * People Picker Pane
       *
       * This pane offers a mechanism for selecting a set of individuals, groups, or
      Severity: Minor
      Found in src/widgets/peoplePicker.js - About 6 hrs to fix

        Function makeDropTarget has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.
        Open

        function makeDropTarget (ele, droppedURIHandler, droppedFileHandler) {
          var dragoverListener = function (e) {
            e.preventDefault() // Neeed else drop does not work [sic]
            e.dataTransfer.dropEffect = 'copy'
          }
        Severity: Minor
        Found in src/widgets/dragAndDrop.js - About 6 hrs to fix

        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 makeSelectForOptions has 170 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        forms.makeSelectForOptions = function (
          dom,
          kb,
          subject,
          predicate,
        Severity: Major
        Found in src/widgets/forms.js - About 6 hrs to fix

          Function addListeners has 165 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            var addListeners = function (part, chunk) {
              part.addEventListener('keydown', function (event) {
                var queueProperty, queue
                //  up 38; down 40; left 37; right 39     tab 9; shift 16; escape 27
                switch (event.keyCode) {
          Severity: Major
          Found in src/pad.js - About 6 hrs to fix

            Function newMessageForm has 163 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              function newMessageForm (messageTable) {
                var form = dom.createElement('tr')
                var lhs = dom.createElement('td')
                var middle = dom.createElement('td')
                var rhs = dom.createElement('td')
            Severity: Major
            Found in src/chat/infinite.js - About 6 hrs to fix

              Function renderMessageTable has 155 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                function renderMessageTable (date, live) {
                  var scrollBackButton
                  var scrollForwardButton
              
                  /// /////////////////   Scroll down adding more above
              Severity: Major
              Found in src/chat/infinite.js - About 6 hrs to fix

                Function selectWorkspace has 151 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                export function selectWorkspace (
                  dom: HTMLDocument,
                  appDetails: AppDetails,
                  callbackWS: (workspace: string | null, newBase: string) => void
                ): HTMLElement {
                Severity: Major
                Found in src/authn/authn.ts - About 6 hrs to fix

                  Function basicField has 134 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  function basicField (
                    dom,
                    container,
                    already,
                    subject,
                  Severity: Major
                  Found in src/widgets/forms.js - About 5 hrs to fix

                    Function label has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
                    Open

                    function label (x, initialCap) {
                      // x is an object
                      function doCap (s) {
                        // s = s.toString()
                        if (initialCap) return s.slice(0, 1).toUpperCase() + s.slice(1)
                    Severity: Minor
                    Found in src/utils.js - About 4 hrs to fix

                    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 messageToolbar has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
                    Open

                    export function messageToolbar (message, messageRow, userContext) {
                      const div = dom.createElement('div')
                      function closeToolbar () {
                        div.parentElement.parentElement.removeChild(div.parentElement) // remive the TR
                      }
                    Severity: Minor
                    Found in src/chat/messageTools.js - About 4 hrs to fix

                    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 renderMessage has 122 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    export function renderMessage (
                      messageTable,
                      bindings,
                      fresh,
                      options,
                    Severity: Major
                    Found in src/chat/message.js - About 4 hrs to fix

                      Function displayOptions has 120 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        function displayOptions (context) {
                          // const status = ''
                          const id = context.me
                          const preferencesFile = context.preferencesFile
                          let newBase = null
                      Severity: Major
                      Found in src/authn/authn.ts - About 4 hrs to fix

                        Function buildCheckboxForm has 115 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        function buildCheckboxForm (dom, kb, lab, del, ins, form, store, tristate) {
                          // 20190115
                          var box = dom.createElement('div')
                          var tx = dom.createTextNode(lab)
                          var editable = UI.store.updater.editable(store.uri)
                        Severity: Major
                        Found in src/widgets/forms.js - About 4 hrs to fix

                          Function messageToolbar has 113 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          export function messageToolbar (message, messageRow, userContext) {
                            const div = dom.createElement('div')
                            function closeToolbar () {
                              div.parentElement.parentElement.removeChild(div.parentElement) // remive the TR
                            }
                          Severity: Major
                          Found in src/chat/messageTools.js - About 4 hrs to fix

                            Function shortName has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
                            Open

                            function shortName (uri) {
                              let p = uri
                              if ('#/'.indexOf(p[p.length - 1]) >= 0) p = p.slice(0, -1)
                              const namespaces = []
                              for (const ns in this.prefixes) {
                            Severity: Minor
                            Found in src/utils.js - About 4 hrs to fix

                            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

                            Severity
                            Category
                            Status
                            Source
                            Language