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

Open

                ).map((predicate) => {
                    const patterns: Pattern[] = [];
                    const selectorPatterns = this.generateSelector(query, predicate, dataType, member, subject);
                    if (selectorPatterns.length > 0) {
                        patterns.push(...selectorPatterns);

Function deserializer has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        deserializer: (thing: Thing) => {
            let yaw = 0;
            let roll = 0;
            let pitch = 0;
            let unit: AngleUnit;

Function serializeLiteral has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    serializeLiteral(
        sourceObject: any,
        typeDescriptor?: TypeDescriptor,
        memberName?: string,
        serializer?: Serializer,

• Read up
  Read up

Function regexPatterns has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

                    (predicate) => {
                        return [
                            {
                                type: 'bgp',
                                triples: [

Function loadClasses has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    protected static loadClasses(module: NodeModule = require.main): void {
        if (module === undefined) {
            // Use cache instead
            Object.values(require.cache).map((m) => this.loadClasses(m));
            return;

Function serializer has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        serializer: (pos: GeographicalPosition) => {
            if (pos.altitude) {
                return {
                    predicates: {
                        [ogc.asWKT]: [

Function convertSingleValue has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    convertSingleValue(
        sourceObject: any,
        typeDescriptor: TypeDescriptor,
        knownTypes: Map<string, Serializable<any>>,
        memberName = 'object',

• Read up
  Read up

Function serializer has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    serializer: (rdf: RDFMetadata) => {
        if (!rdf) {
            return undefined;
        }

• Read up
  Read up

Function createConstruct has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    protected createConstruct(query: FilterQuery, dataType?: Serializable<T>): ConstructQuery {
        const patterns: Pattern[] = [];
        // Create a pattern for the datatype
        const finalDataType = dataType || this.dataType;
        if (finalDataType) {

• Read up
  Read up

Function deserializer has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        deserializer: (thing: Thing) => {
            let yaw = 0;
            let roll = 0;
            let pitch = 0;
            let unit: AngleUnit;

• Read up
  Read up

Function deserializer has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        deserializer: (thing: Thing) => {
            let yaw = 0;
            let roll = 0;
            let pitch = 0;
            let unit: AngleUnit;

• Read up
  Read up

Function getTs has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

export function getTs(node: NamedNode, store: Store, namespace: string, entityTypes: { [alias: string]: string }): string {
    const types = store.getObjects(node, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', null);
    const entityType = types.length > 0 ? Object.entries(entityTypes).find(
        ([_alias, type]) => type === types[0].id,
    ) : undefined;

• Read up
  Read up

Function createChangeLog has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

export function createChangeLog(store: Store): Store & RDFChangeLog {
    // Add a changelog to the store
    (store as any).additions = [];
    (store as any).deletions = [];

• Read up
  Read up

Avoid too many return statements within this function.

Open

            return this.deserializeObject(
                sourceObject,
                typeDescriptor,
                knownTypes,
                memberName,

Avoid too many return statements within this function.

Open

        return false;

Avoid too many return statements within this function.

Open

            return serializer(sourceObject, typeDescriptor, memberName, this, memberOptions, serializerOptions);

Avoid too many return statements within this function.

Open

            return this.serializeObject(
                sourceObject,
                typeDescriptor,
                memberName,
                this,

Avoid too many return statements within this function.

Open

                return output as NamedNode;

Avoid too many return statements within this function.

Open

                return mergeDeep(
                    {
                        termType: 'BlankNode',
                        value: this.blankNode(undefined, serializerOptions).value,
                        predicates: {},

Avoid too many return statements within this function.

Open

        return thing;