Microsoft/fast-dna

View on GitHub
packages/web-components/fast-element/src/di/di.get.spec.ts

Summary

Maintainability
F
1 wk
Test Coverage

File di.get.spec.ts has 588 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import { expect } from "chai";
import {
    all,
    DI,
    Container,
Severity: Major
Found in packages/web-components/fast-element/src/di/di.get.spec.ts - About 1 day to fix

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

                    it("children", function () {
                        const root = DI.createContainer();
                        const child1 = root.createChild();
                        const child2 = root.createChild();
    
    
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 2 other locations - About 1 day to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 74..94
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 104..124

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 227.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

                    it("root", function () {
                        const root = DI.createContainer();
                        const child1 = root.createChild();
                        const child2 = root.createChild();
    
    
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 2 other locations - About 1 day to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 104..124
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 132..152

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 227.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

                    it("children", function () {
                        const root = DI.createContainer();
                        const child1 = root.createChild();
                        const child2 = root.createChild();
    
    
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 2 other locations - About 1 day to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 74..94
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 132..152

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 227.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

                it("Set", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Set) private readonly test: Set<unknown>
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 370..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

                it("Promise", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Promise) private readonly test: Promise<unknown>
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 408..416

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

                it("Function", function () {
                    @singleton
                    class Foo {
                        // eslint-disable-next-line @typescript-eslint/ban-types
                        public constructor(
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 3 other locations - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 237..244
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 352..359
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 361..368

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 75.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

                it("Object", function () {
                    @singleton
                    class Foo {
                        // eslint-disable-next-line @typescript-eslint/ban-types
                        public constructor(@inject(Object) private readonly test: Object) {}
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 3 other locations - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 237..244
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 301..310
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 352..359

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 75.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

                it("Boolean", function () {
                    @singleton
                    class Foo {
                        // eslint-disable-next-line @typescript-eslint/ban-types
                        public constructor(@inject(Boolean) private readonly test: Boolean) {}
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 3 other locations - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 301..310
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 352..359
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 361..368

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 75.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 4 locations. Consider refactoring.
    Open

                it("Number", function () {
                    @singleton
                    class Foo {
                        // eslint-disable-next-line @typescript-eslint/ban-types
                        public constructor(@inject(Number) private readonly test: Number) {}
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 3 other locations - About 2 hrs to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 237..244
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 301..310
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 361..368

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 75.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Date", function () {
                    @singleton
                    class Foo {
                        public constructor(@inject(Date) private readonly test: Date) {}
                    }
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("TypeError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(TypeError) private readonly test: TypeError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Float32Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Float32Array) private readonly test: Float32Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Uint8Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Uint8Array) private readonly test: Uint8Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Uint16Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Uint16Array) private readonly test: Uint16Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("EvalError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(EvalError) private readonly test: EvalError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("UriError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(URIError) private readonly test: URIError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Error", function () {
                    @singleton
                    class Foo {
                        public constructor(@inject(Error) private readonly test: Error) {}
                    }
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("RangeError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(RangeError) private readonly test: RangeError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("DataView", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(DataView) private readonly test: DataView
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Int32Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Int32Array) private readonly test: Int16Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("ReferenceError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(ReferenceError) private readonly test: ReferenceError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("ArrayBuffer", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(ArrayBuffer) private readonly test: ArrayBuffer
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Uint8ClampedArray", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Uint8ClampedArray)
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("SyntaxError", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(SyntaxError) private readonly test: SyntaxError
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Uint32Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Uint32Array) private readonly test: Uint32Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Float64Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Float64Array) private readonly test: Float64Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Int8Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Int8Array) private readonly test: Int8Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("Int16Array", function () {
                    @singleton
                    class Foo {
                        public constructor(
                            @inject(Int16Array) private readonly test: Int16Array
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 400..406
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 20 locations. Consider refactoring.
    Open

                it("RegExp", function () {
                    @singleton
                    class Foo {
                        public constructor(@inject(RegExp) private readonly test: RegExp) {}
                    }
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 227..235
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 246..254
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 256..262
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 263..269
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 271..279
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 281..289
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 291..299
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 312..320
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 322..330
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 332..340
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 380..388
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 390..398
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 438..446
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 448..456
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 458..466
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 468..477
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 479..487
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 488..496
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 497..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

            it("no default, but param allows undefined", function () {
                class Foo {
                    public constructor(@optional("key") public readonly test?: string) {}
                }
    
    
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 1 hr to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 176..182

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

            it("no default, param does not allow undefind", function () {
                class Foo {
                    public constructor(@optional("key") public readonly test: string) {}
                }
    
    
    Severity: Major
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 1 hr to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 168..174

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 73.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

            class Test {
                constructor(
                    @inject(key1) public one,
                    @inject(key2) public two,
                    @inject(key3) public three
    Severity: Minor
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 35 mins to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 644..650

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 47.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

            class Test {
                constructor(
                    @inject(key1) public one,
                    @inject(key2) public two,
                    @inject(key3) public three
    Severity: Minor
    Found in packages/web-components/fast-element/src/di/di.get.spec.ts and 1 other location - About 35 mins to fix
    packages/web-components/fast-element/src/di/di.get.spec.ts on lines 613..619

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 47.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    There are no issues that match your filters.

    Category
    Status