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

Open

    findByParentUID(parentUID: string): Promise<T[]> {
        return this.findAll({
            parentUID,
        }) as Promise<T[]>;
    }

• Read up
  Read up

Function _convertSingleValue has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private _convertSingleValue(
        sourceObject: any,
        typeDescriptor: TypeDescriptor,
        knownTypes: Map<string, Serializable<any>>,
        memberName: string,

Function findAll has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public findAll(query?: FilterQuery<T>, options: FindOptions = {}): Promise<T[]> {
        return new Promise<T[]>((resolve) => {
            options.limit = options.limit || this._data.size;
            let data: T[] = [];
            this._data.forEach((object) => {

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

Open

    set linearVelocity(value: LinearVelocity) {
        if (!this.velocity) {
            this.velocity = new Velocity();
        }
        this.velocity.linear = value;

• Read up
  Read up

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

Open

    set angularVelocity(value: AngularVelocity) {
        if (!this.velocity) {
            this.velocity = new Velocity();
        }
        this.velocity.angular = value;

• Read up
  Read up

Function updateSerializableObject has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function updateSerializableObject<T>(target: Serializable<T>, options: SerializableObjectOptions<T>): void {
    const ownMeta = DataSerializerUtils.getMetadata(target);
    const rootMeta = DataSerializerUtils.getRootMetadata(target.prototype);
    rootMeta.knownTypes.add(target);
    if (rootMeta.initializerCallback && !ownMeta.initializerCallback) {

Function callService has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    callService(call: WorkerServiceCall): Promise<WorkerServiceResponse> {
        return new Promise((resolve, reject) => {
            const service: Service =
                this.model.findDataService(call.serviceUID) || this.model.findService(call.serviceUID);
            if ((service as any)[call.method]) {

Function trilaterate has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    protected trilaterate<P extends AbsolutePosition>(spheres: Array<Sphere<P>>): Promise<P> {
        return new Promise<P>((resolve) => {
            const maxIterations = this.options.maxIterations || 900;
            const v = spheres.map((p) => p.center);
            const ex = v[1].clone().sub(v[0]).normalize();

Function processRelativePositions has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public processRelativePositions<P extends Absolute2DPosition | Absolute3DPosition | GeographicalPosition>(
        dataObject: DataObject,
        relativePositions: Map<RelativeAngle, DataObject>,
        dataFrame: DataFrame,
    ): Promise<DataObject> {

Function constructor has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    constructor(
        x?: number,
        y?: number,
        z?: number,
        unit?: Unit,

• Read up
  Read up

Function swap has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    swap(subunits: Unit[], options?: UnitOptions): DerivedUnit {
        if (Unit.UNITS.has(options.name)) {
            return Unit.UNITS.get(options.name) as this;
        }

Function createDefinition has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    createDefinition(targetUnit: Unit): UnitFunctionDefinition<any, any> {
        let newDefinition: UnitFunctionDefinition<any, any>;

        // Get base unit
        const baseUnitName = Unit.UNIT_BASES.get(this.baseName);

Function merge has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public merge(frames: InOut[]): InOut {
        const mergedFrame = frames[0];
        const mergedObjects: Map<string, DataObject[]> = new Map();
        mergedFrame.getObjects().forEach((object) => {
            if (mergedObjects.get(object.uid)) {

Function createHandler has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    createHandler(target: Service, p: PropertyKey): (...args: any[]) => any {
        return (...args: any[]) =>
            new Promise<any>((resolve, reject) => {
                const uuid = uuidv4();
                this._promises.set(uuid, { resolve, reject });

Function convertAsArray has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    convertAsArray(
        sourceObject: Array<any>,
        typeDescriptor: ArrayTypeDescriptor,
        memberName: string,
        serializer: Serializer,

Function _onWorkerService has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private _onWorkerService(threadId: number, value: WorkerServiceCall): void {
        const service: Service =
            this.model.findDataService(value.serviceUID) || this.model.findService(value.serviceUID);
        if ((service as any)[value.method]) {
            const serializedParams = value.parameters;

Function midpointGeographical has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    protected midpointGeographical(
        sphereA: Sphere<GeographicalPosition>,
        sphereB: Sphere<GeographicalPosition>,
    ): GeographicalPosition {
        const pointA = sphereA.position;

Function processObject has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public processObject(dataObject: DataObject, dataFrame: InOut): Promise<DataObject> {
        return new Promise((resolve, reject) => {
            const referencePromises: Array<Promise<DataObject>> = [];
            const index = new Map<string, R>();
            for (const relativePosition of dataObject.relativePositions) {

Function process has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public process(frame: InOut, options?: GraphOptions): Promise<InOut> {
        return new Promise<InOut>((resolve, reject) => {
            const processObjectPromises: Array<Promise<DataObject>> = [];
            const uids = [];
            const sourceUID = frame.source ? frame.source.uid : undefined;

Function onPull has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public onPull(options: PullOptions = { requestedObjects: [] }): Promise<Out> {
        return new Promise<Out>((resolve, reject) => {
            const service = this.model.findDataService(DataObject);
            const requestPromises: Array<Promise<DataObject>> = [];
            options.requestedObjects.forEach((uid) => {