axe312ger/sqip

View on GitHub

Showing 25 of 39 total issues

File sqip.ts has 402 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import path from 'path'

import Debug from 'debug'
import fs from 'fs-extra'

Severity: Minor
Found in packages/sqip/src/sqip.ts - About 5 hrs to fix

    Function processFile has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
    Open

    async function processFile({
      filePath,
      buffer,
      outputFileName,
      config
    Severity: Minor
    Found in packages/sqip/src/sqip.ts - 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 apply has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

      async apply(
        imageBuffer: Buffer,
        metadata: SqipImageMetadata
      ): Promise<Buffer> {
        if (metadata.type === 'svg') {
    Severity: Minor
    Found in packages/sqip-plugin-pixels/src/sqip-plugin-pixels.ts - 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 apply has 97 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      async apply(
        imageBuffer: Buffer,
        metadata: SqipImageMetadata
      ): Promise<Buffer> {
        if (metadata.type === 'svg') {
    Severity: Major
    Found in packages/sqip-plugin-pixels/src/sqip-plugin-pixels.ts - About 3 hrs to fix

      Function sqipCLI has 90 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      export default async function sqipCLI(): Promise<undefined> {
        const pluginDetectionArgs = commandLineArgs(defaultOptionList, {
          partial: true
        })
      
      
      Severity: Major
      Found in packages/sqip-cli/src/sqip-cli.ts - About 3 hrs to fix

        Function cliOptions has 70 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          static get cliOptions(): SqipCliOptionDefinition[] {
            return [
              {
                name: 'color',
                type: String,
        Severity: Major
        Found in packages/sqip-plugin-potrace/src/sqip-plugin-potrace.ts - About 2 hrs to fix

          Function cliOptions has 66 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            static get cliOptions(): SqipCliOptionDefinition[] {
              return [
                { name: 'bl', type: Number, description: 'Blur radius', defaultValue: 2 },
                {
                  name: 'nf',
          Severity: Major
          Found in packages/sqip-plugin-triangle/src/sqip-plugin-triangle.ts - About 2 hrs to fix

            Function sqip has 65 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            export async function sqip(
              options: SqipOptions
            ): Promise<SqipResult | SqipResult[]> {
              // Build configuration based on passed options and default options
              const defaultOptions = {
            Severity: Major
            Found in packages/sqip/src/sqip.ts - About 2 hrs to fix

              Function apply has 60 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                async apply(
                  imageBuffer: Buffer,
                  metadata: SqipImageMetadata
                ): Promise<Buffer> {
                  if (metadata.type === 'svg') {
              Severity: Major
              Found in packages/sqip-plugin-potrace/src/sqip-plugin-potrace.ts - About 2 hrs to fix

                Function apply has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  async apply(
                    imageBuffer: Buffer,
                    metadata: SqipImageMetadata
                  ): Promise<Buffer> {
                    if (metadata.type === 'svg') {
                Severity: Major
                Found in packages/sqip-plugin-primitive/src/sqip-plugin-primitive.ts - About 2 hrs to fix

                  Function apply has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    async apply(
                      imageBuffer: Buffer,
                      metadata: SqipImageMetadata
                    ): Promise<Buffer> {
                      if (metadata.type === 'svg') {
                  Severity: Major
                  Found in packages/sqip-plugin-triangle/src/sqip-plugin-triangle.ts - About 2 hrs to fix

                    Function apply has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      async apply(
                        imageBuffer: Buffer,
                        metadata: SqipImageMetadata
                      ): Promise<Buffer> {
                        if (metadata.type === 'svg') {
                    Severity: Major
                    Found in packages/sqip-plugin-blurhash/src/sqip-plugin-blurhash.ts - About 2 hrs to fix

                      Function cliOptions has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        static get cliOptions(): SqipCliOptionDefinition[] {
                          return [
                            {
                              name: 'numberOfPrimitives',
                              alias: 'n',
                      Severity: Major
                      Found in packages/sqip-plugin-primitive/src/sqip-plugin-primitive.ts - About 2 hrs to fix

                        Function findBackgroundColor has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        export async function findBackgroundColor(imageBuffer: Buffer): Promise<string> {
                          const image = sharp(imageBuffer)
                          const { width, height } = await image.metadata()
                        
                          if (!width || !height) {
                        Severity: Minor
                        Found in packages/sqip/src/helpers.ts - About 1 hr to fix

                          Function apply has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            async apply(
                              imageBuffer: Buffer,
                              metadata: SqipImageMetadata
                            ): Promise<Buffer> {
                              if (!this.options.blur) {
                          Severity: Minor
                          Found in packages/sqip-plugin-blur/src/sqip-plugin-blur.ts - About 1 hr to fix

                            Function constructor has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                              constructor(options: SvgoPluginOptions) {
                                super(options)
                            
                                const { pluginOptions } = options
                            
                            
                            Severity: Minor
                            Found in packages/sqip-plugin-svgo/src/sqip-plugin-svgo.ts - About 1 hr to fix

                              Function sqip has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                              Open

                              export async function sqip(
                                options: SqipOptions
                              ): Promise<SqipResult | SqipResult[]> {
                                // Build configuration based on passed options and default options
                                const defaultOptions = {
                              Severity: Minor
                              Found in packages/sqip/src/sqip.ts - About 1 hr 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 sqipCLI has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
                              Open

                              export default async function sqipCLI(): Promise<undefined> {
                                const pluginDetectionArgs = commandLineArgs(defaultOptionList, {
                                  partial: true
                                })
                              
                              
                              Severity: Minor
                              Found in packages/sqip-cli/src/sqip-cli.ts - About 1 hr 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 processImage has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
                              Open

                              async function processImage({
                                filePath,
                                buffer,
                                config
                              }: ProcessImageOptions): Promise<SqipResult> {
                              Severity: Minor
                              Found in packages/sqip/src/sqip.ts - About 1 hr 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 locateFiles has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              export async function locateFiles(input: string): Promise<string[]> {
                                const enhancedInput = expandTilde(input)
                                let globPattern = enhancedInput
                                try {
                                  const stat = await fs.lstat(enhancedInput)
                              Severity: Minor
                              Found in packages/sqip/src/helpers.ts - About 1 hr to fix
                                Severity
                                Category
                                Status
                                Source
                                Language