@cparra/apexdocs 2.23.0 → 2.24.0

package/lib/service/parser.js

@@ -1,135 +1,135 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawBodyParser = void 0;
-const metadata_processor_1 = require("./metadata-processor");
-const logger_1 = require("../util/logger");
-class RawBodyParser {
-    constructor(typeBundles) {
-        this.typeBundles = typeBundles;
-    }
-    parse(reflect) {
-        const types = this.typeBundles
-            .map((currentBundle) => {
-            logger_1.Logger.log(`Parsing file: ${currentBundle.filePath}`);
-            const result = reflect(currentBundle);
-            if (!!result.typeMirror && !!currentBundle.rawMetadataContent) {
-                // If successful and there is a metadata file
-                const metadataParams = metadata_processor_1.default.process(currentBundle.rawMetadataContent);
-                metadataParams.forEach((value, key) => {
-                    var _a;
-                    const declaration = `${key}: ${value}`;
-                    (_a = result.typeMirror) === null || _a === void 0 ? void 0 : _a.annotations.push({
-                        rawDeclaration: declaration,
-                        name: declaration,
-                        type: declaration,
-                    });
-                });
-            }
-            return result;
-        })
-            .filter((reflectionResult) => {
-            return reflectionResult.typeMirror;
-        })
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            .map((reflectionResult) => reflectionResult.typeMirror);
-        return this.addFieldsFromParent(types);
-    }
-    addFieldsFromParent(types) {
-        const typesWithFields = [];
-        for (const currentType of types) {
-            if (currentType.type_name !== 'class' && currentType.type_name !== 'interface') {
-                typesWithFields.push(currentType);
-                continue;
-            }
-            if (currentType.type_name === 'class') {
-                let typeAsClass = currentType;
-                if (!typeAsClass.extended_class) {
-                    typesWithFields.push(currentType);
-                    continue;
-                }
-                typeAsClass = this.addMembersFromParent(typeAsClass, types);
-                typesWithFields.push(typeAsClass);
-                continue;
-            }
-            // If reaching here then we are dealing with an interface
-            let typeAsInterface = currentType;
-            if (!typeAsInterface.extended_interfaces.length) {
-                typesWithFields.push(currentType);
-                continue;
-            }
-            typeAsInterface = this.addMethodsFromParent(typeAsInterface, types);
-            typesWithFields.push(typeAsInterface);
-        }
-        return typesWithFields;
-    }
-    addMembersFromParent(currentClass, allTypes) {
-        if (!currentClass.extended_class) {
-            return currentClass;
-        }
-        const parent = allTypes.find((currentType) => currentType.name === currentClass.extended_class);
-        if (!parent || parent.type_name !== 'class') {
-            return currentClass;
-        }
-        let parentAsClass = parent;
-        if (parentAsClass.extended_class) {
-            parentAsClass = this.addMembersFromParent(parentAsClass, allTypes);
-        }
-        currentClass.fields = [...currentClass.fields, ...this.getInheritedFields(parentAsClass, currentClass)];
-        currentClass.properties = [...currentClass.properties, ...this.getInheritedProperties(parentAsClass, currentClass)];
-        currentClass.methods = [...currentClass.methods, ...this.getInheritedMethods(parentAsClass, currentClass)];
-        return currentClass;
-    }
-    addMethodsFromParent(currentInterface, allTypes) {
-        if (!currentInterface.extended_interfaces.length) {
-            return currentInterface;
-        }
-        const parents = [];
-        for (const currentInterfaceName of currentInterface.extended_interfaces) {
-            const parent = allTypes.find((currentType) => currentType.name === currentInterfaceName);
-            if (parent) {
-                parents.push(parent);
-            }
-        }
-        for (const parent of parents) {
-            let parentAsInterface = parent;
-            if (parentAsInterface.extended_interfaces.length) {
-                parentAsInterface = this.addMethodsFromParent(parentAsInterface, allTypes);
-            }
-            currentInterface.methods = [
-                ...currentInterface.methods,
-                ...this.getInheritedMethods(parentAsInterface, currentInterface),
-            ];
-        }
-        return currentInterface;
-    }
-    getInheritedFields(parentAsClass, currentClass) {
-        return (parentAsClass.fields
-            // Filter out private fields
-            .filter((currentField) => currentField.access_modifier.toLowerCase() !== 'private')
-            // Filter out fields that also exist on the child
-            .filter((currentField) => !this.memberExists(currentClass.fields, currentField.name))
-            .map((currentField) => (Object.assign(Object.assign({}, currentField), { inherited: true }))));
-    }
-    getInheritedProperties(parentAsClass, currentClass) {
-        return (parentAsClass.properties
-            // Filter out private properties
-            .filter((currentProperty) => currentProperty.access_modifier.toLowerCase() !== 'private')
-            // Filter out properties that also exist on the child
-            .filter((currentProperty) => !this.memberExists(currentClass.properties, currentProperty.name))
-            .map((currentProperty) => (Object.assign(Object.assign({}, currentProperty), { inherited: true }))));
-    }
-    getInheritedMethods(parentAsClass, currentClass) {
-        return (parentAsClass.methods
-            // Filter out private methods
-            .filter((currentMethod) => currentMethod.access_modifier.toLowerCase() !== 'private')
-            // Filter out methods that also exist on the child
-            .filter((currentMethod) => !this.memberExists(currentClass.methods, currentMethod.name))
-            .map((currentMethod) => (Object.assign(Object.assign({}, currentMethod), { inherited: true }))));
-    }
-    memberExists(members, fieldName) {
-        const fieldNames = members.map((currentMember) => currentMember.name);
-        return fieldNames.includes(fieldName);
-    }
-}
-exports.RawBodyParser = RawBodyParser;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawBodyParser = void 0;
+const metadata_processor_1 = require("./metadata-processor");
+const logger_1 = require("../util/logger");
+class RawBodyParser {
+    constructor(typeBundles) {
+        this.typeBundles = typeBundles;
+    }
+    parse(reflect) {
+        const types = this.typeBundles
+            .map((currentBundle) => {
+            logger_1.Logger.log(`Parsing file: ${currentBundle.filePath}`);
+            const result = reflect(currentBundle);
+            if (!!result.typeMirror && !!currentBundle.rawMetadataContent) {
+                // If successful and there is a metadata file
+                const metadataParams = metadata_processor_1.default.process(currentBundle.rawMetadataContent);
+                metadataParams.forEach((value, key) => {
+                    var _a;
+                    const declaration = `${key}: ${value}`;
+                    (_a = result.typeMirror) === null || _a === void 0 ? void 0 : _a.annotations.push({
+                        rawDeclaration: declaration,
+                        name: declaration,
+                        type: declaration,
+                    });
+                });
+            }
+            return result;
+        })
+            .filter((reflectionResult) => {
+            return reflectionResult.typeMirror;
+        })
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            .map((reflectionResult) => reflectionResult.typeMirror);
+        return this.addFieldsFromParent(types);
+    }
+    addFieldsFromParent(types) {
+        const typesWithFields = [];
+        for (const currentType of types) {
+            if (currentType.type_name !== 'class' && currentType.type_name !== 'interface') {
+                typesWithFields.push(currentType);
+                continue;
+            }
+            if (currentType.type_name === 'class') {
+                let typeAsClass = currentType;
+                if (!typeAsClass.extended_class) {
+                    typesWithFields.push(currentType);
+                    continue;
+                }
+                typeAsClass = this.addMembersFromParent(typeAsClass, types);
+                typesWithFields.push(typeAsClass);
+                continue;
+            }
+            // If reaching here then we are dealing with an interface
+            let typeAsInterface = currentType;
+            if (!typeAsInterface.extended_interfaces.length) {
+                typesWithFields.push(currentType);
+                continue;
+            }
+            typeAsInterface = this.addMethodsFromParent(typeAsInterface, types);
+            typesWithFields.push(typeAsInterface);
+        }
+        return typesWithFields;
+    }
+    addMembersFromParent(currentClass, allTypes) {
+        if (!currentClass.extended_class) {
+            return currentClass;
+        }
+        const parent = allTypes.find((currentType) => currentType.name === currentClass.extended_class);
+        if (!parent || parent.type_name !== 'class') {
+            return currentClass;
+        }
+        let parentAsClass = parent;
+        if (parentAsClass.extended_class) {
+            parentAsClass = this.addMembersFromParent(parentAsClass, allTypes);
+        }
+        currentClass.fields = [...currentClass.fields, ...this.getInheritedFields(parentAsClass, currentClass)];
+        currentClass.properties = [...currentClass.properties, ...this.getInheritedProperties(parentAsClass, currentClass)];
+        currentClass.methods = [...currentClass.methods, ...this.getInheritedMethods(parentAsClass, currentClass)];
+        return currentClass;
+    }
+    addMethodsFromParent(currentInterface, allTypes) {
+        if (!currentInterface.extended_interfaces.length) {
+            return currentInterface;
+        }
+        const parents = [];
+        for (const currentInterfaceName of currentInterface.extended_interfaces) {
+            const parent = allTypes.find((currentType) => currentType.name === currentInterfaceName);
+            if (parent) {
+                parents.push(parent);
+            }
+        }
+        for (const parent of parents) {
+            let parentAsInterface = parent;
+            if (parentAsInterface.extended_interfaces.length) {
+                parentAsInterface = this.addMethodsFromParent(parentAsInterface, allTypes);
+            }
+            currentInterface.methods = [
+                ...currentInterface.methods,
+                ...this.getInheritedMethods(parentAsInterface, currentInterface),
+            ];
+        }
+        return currentInterface;
+    }
+    getInheritedFields(parentAsClass, currentClass) {
+        return (parentAsClass.fields
+            // Filter out private fields
+            .filter((currentField) => currentField.access_modifier.toLowerCase() !== 'private')
+            // Filter out fields that also exist on the child
+            .filter((currentField) => !this.memberExists(currentClass.fields, currentField.name))
+            .map((currentField) => (Object.assign(Object.assign({}, currentField), { inherited: true }))));
+    }
+    getInheritedProperties(parentAsClass, currentClass) {
+        return (parentAsClass.properties
+            // Filter out private properties
+            .filter((currentProperty) => currentProperty.access_modifier.toLowerCase() !== 'private')
+            // Filter out properties that also exist on the child
+            .filter((currentProperty) => !this.memberExists(currentClass.properties, currentProperty.name))
+            .map((currentProperty) => (Object.assign(Object.assign({}, currentProperty), { inherited: true }))));
+    }
+    getInheritedMethods(parentAsClass, currentClass) {
+        return (parentAsClass.methods
+            // Filter out private methods
+            .filter((currentMethod) => currentMethod.access_modifier.toLowerCase() !== 'private')
+            // Filter out methods that also exist on the child
+            .filter((currentMethod) => !this.memberExists(currentClass.methods, currentMethod.name))
+            .map((currentMethod) => (Object.assign(Object.assign({}, currentMethod), { inherited: true }))));
+    }
+    memberExists(members, fieldName) {
+        const fieldNames = members.map((currentMember) => currentMember.name);
+        return fieldNames.includes(fieldName);
+    }
+}
+exports.RawBodyParser = RawBodyParser;
 //# sourceMappingURL=parser.js.map

package/lib/service/state.d.ts

@@ -1,9 +1,9 @@
-import { Type } from '@cparra/apex-reflection';
-export default class State {
-    private static instance;
-    private typeBeingProcessed?;
-    private constructor();
-    static getInstance(): State;
-    setTypeBeingProcessed(typeToSet: Type): void;
-    getTypeBeingProcessed(): Type | undefined;
-}
+import { Type } from '@cparra/apex-reflection';
+export default class State {
+    private static instance;
+    private typeBeingProcessed?;
+    private constructor();
+    static getInstance(): State;
+    setTypeBeingProcessed(typeToSet: Type): void;
+    getTypeBeingProcessed(): Type | undefined;
+}

package/lib/service/state.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class State {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    constructor() { }
-    static getInstance() {
-        if (!State.instance) {
-            State.instance = new State();
-        }
-        return State.instance;
-    }
-    setTypeBeingProcessed(typeToSet) {
-        this.typeBeingProcessed = typeToSet;
-    }
-    getTypeBeingProcessed() {
-        return this.typeBeingProcessed;
-    }
-}
-exports.default = State;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class State {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor() { }
+    static getInstance() {
+        if (!State.instance) {
+            State.instance = new State();
+        }
+        return State.instance;
+    }
+    setTypeBeingProcessed(typeToSet) {
+        this.typeBeingProcessed = typeToSet;
+    }
+    getTypeBeingProcessed() {
+        return this.typeBeingProcessed;
+    }
+}
+exports.default = State;
 //# sourceMappingURL=state.js.map

package/lib/service/walkers/class-walker.d.ts

@@ -1,4 +1,4 @@
-import { Walker, WalkerListener } from './walker';
-export declare class ClassWalker extends Walker {
-    walk(listener: WalkerListener): void;
-}
+import { Walker, WalkerListener } from './walker';
+export declare class ClassWalker extends Walker {
+    walk(listener: WalkerListener): void;
+}

package/lib/service/walkers/class-walker.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassWalker = void 0;
-const walker_1 = require("./walker");
-class ClassWalker extends walker_1.Walker {
-    walk(listener) {
-        listener.onTypeDeclaration(this.type);
-        const classMirror = this.type;
-        if (classMirror.constructors.length) {
-            listener.onConstructorDeclaration(this.type.name, classMirror.constructors);
-        }
-        if (classMirror.fields.length) {
-            listener.onFieldsDeclaration(this.sortType(classMirror.fields));
-        }
-        if (classMirror.properties.length) {
-            listener.onPropertiesDeclaration(this.sortType(classMirror.properties));
-        }
-        if (classMirror.methods.length) {
-            listener.onMethodsDeclaration(this.sortType(classMirror.methods));
-        }
-        if (classMirror.enums.length) {
-            listener.onInnerEnumsDeclaration(this.sortType(classMirror.enums));
-        }
-        if (classMirror.classes.length) {
-            listener.onInnerClassesDeclaration(this.sortType(classMirror.classes));
-        }
-        if (classMirror.interfaces.length) {
-            listener.onInnerInterfacesDeclaration(this.sortType(classMirror.interfaces));
-        }
-    }
-}
-exports.ClassWalker = ClassWalker;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassWalker = void 0;
+const walker_1 = require("./walker");
+class ClassWalker extends walker_1.Walker {
+    walk(listener) {
+        listener.onTypeDeclaration(this.type);
+        const classMirror = this.type;
+        if (classMirror.constructors.length) {
+            listener.onConstructorDeclaration(this.type.name, classMirror.constructors);
+        }
+        if (classMirror.fields.length) {
+            listener.onFieldsDeclaration(this.sortType(classMirror.fields));
+        }
+        if (classMirror.properties.length) {
+            listener.onPropertiesDeclaration(this.sortType(classMirror.properties));
+        }
+        if (classMirror.methods.length) {
+            listener.onMethodsDeclaration(this.sortType(classMirror.methods));
+        }
+        if (classMirror.enums.length) {
+            listener.onInnerEnumsDeclaration(this.sortType(classMirror.enums));
+        }
+        if (classMirror.classes.length) {
+            listener.onInnerClassesDeclaration(this.sortType(classMirror.classes));
+        }
+        if (classMirror.interfaces.length) {
+            listener.onInnerInterfacesDeclaration(this.sortType(classMirror.interfaces));
+        }
+    }
+}
+exports.ClassWalker = ClassWalker;
 //# sourceMappingURL=class-walker.js.map

package/lib/service/walkers/enum-walker.d.ts

@@ -1,4 +1,4 @@
-import { Walker, WalkerListener } from './walker';
-export declare class EnumWalker extends Walker {
-    walk(listener: WalkerListener): void;
-}
+import { Walker, WalkerListener } from './walker';
+export declare class EnumWalker extends Walker {
+    walk(listener: WalkerListener): void;
+}

package/lib/service/walkers/enum-walker.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumWalker = void 0;
-const walker_1 = require("./walker");
-class EnumWalker extends walker_1.Walker {
-    walk(listener) {
-        listener.onTypeDeclaration(this.type);
-    }
-}
-exports.EnumWalker = EnumWalker;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumWalker = void 0;
+const walker_1 = require("./walker");
+class EnumWalker extends walker_1.Walker {
+    walk(listener) {
+        listener.onTypeDeclaration(this.type);
+    }
+}
+exports.EnumWalker = EnumWalker;
 //# sourceMappingURL=enum-walker.js.map

package/lib/service/walkers/interface-walker.d.ts

@@ -1,4 +1,4 @@
-import { Walker, WalkerListener } from './walker';
-export declare class InterfaceWalker extends Walker {
-    walk(listener: WalkerListener): void;
-}
+import { Walker, WalkerListener } from './walker';
+export declare class InterfaceWalker extends Walker {
+    walk(listener: WalkerListener): void;
+}

package/lib/service/walkers/interface-walker.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InterfaceWalker = void 0;
-const walker_1 = require("./walker");
-class InterfaceWalker extends walker_1.Walker {
-    walk(listener) {
-        listener.onTypeDeclaration(this.type);
-        const interfaceMirror = this.type;
-        if (interfaceMirror.methods.length) {
-            listener.onMethodsDeclaration(this.sortType(interfaceMirror.methods));
-        }
-    }
-}
-exports.InterfaceWalker = InterfaceWalker;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceWalker = void 0;
+const walker_1 = require("./walker");
+class InterfaceWalker extends walker_1.Walker {
+    walk(listener) {
+        listener.onTypeDeclaration(this.type);
+        const interfaceMirror = this.type;
+        if (interfaceMirror.methods.length) {
+            listener.onMethodsDeclaration(this.sortType(interfaceMirror.methods));
+        }
+    }
+}
+exports.InterfaceWalker = InterfaceWalker;
 //# sourceMappingURL=interface-walker.js.map

package/lib/service/walkers/walker-factory.d.ts

@@ -1,5 +1,5 @@
-import { Type } from '@cparra/apex-reflection';
-import { Walker } from './walker';
-export declare class WalkerFactory {
-    static get(type: Type): Walker;
-}
+import { Type } from '@cparra/apex-reflection';
+import { Walker } from './walker';
+export declare class WalkerFactory {
+    static get(type: Type): Walker;
+}

package/lib/service/walkers/walker-factory.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalkerFactory = void 0;
-const class_walker_1 = require("./class-walker");
-const enum_walker_1 = require("./enum-walker");
-const interface_walker_1 = require("./interface-walker");
-class WalkerFactory {
-    static get(type) {
-        switch (type.type_name) {
-            case 'class':
-                return new class_walker_1.ClassWalker(type);
-            case 'enum':
-                return new enum_walker_1.EnumWalker(type);
-            case 'interface':
-                return new interface_walker_1.InterfaceWalker(type);
-        }
-        throw Error('Walker not found for type.');
-    }
-}
-exports.WalkerFactory = WalkerFactory;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalkerFactory = void 0;
+const class_walker_1 = require("./class-walker");
+const enum_walker_1 = require("./enum-walker");
+const interface_walker_1 = require("./interface-walker");
+class WalkerFactory {
+    static get(type) {
+        switch (type.type_name) {
+            case 'class':
+                return new class_walker_1.ClassWalker(type);
+            case 'enum':
+                return new enum_walker_1.EnumWalker(type);
+            case 'interface':
+                return new interface_walker_1.InterfaceWalker(type);
+        }
+        throw Error('Walker not found for type.');
+    }
+}
+exports.WalkerFactory = WalkerFactory;
 //# sourceMappingURL=walker-factory.js.map

package/lib/service/walkers/walker.d.ts

@@ -1,19 +1,19 @@
-import { ClassMirror, ConstructorMirror, EnumMirror, FieldMirror, InterfaceMirror, MethodMirror, PropertyMirror, Type } from '@cparra/apex-reflection';
-export interface WalkerListener {
-    onTypeDeclaration(typeMirror: Type): void;
-    onConstructorDeclaration(className: string, constructors: ConstructorMirror[]): void;
-    onFieldsDeclaration(fields: FieldMirror[]): void;
-    onPropertiesDeclaration(properties: PropertyMirror[]): void;
-    onMethodsDeclaration(methods: MethodMirror[]): void;
-    onInnerEnumsDeclaration(enums: EnumMirror[]): void;
-    onInnerClassesDeclaration(classes: ClassMirror[]): void;
-    onInnerInterfacesDeclaration(interfaces: InterfaceMirror[]): void;
-}
-export declare abstract class Walker {
-    type: Type;
-    constructor(type: Type);
-    abstract walk(listener: WalkerListener): void;
-    protected sortType<T extends {
-        name: string;
-    }>(types: T[]): T[];
-}
+import { ClassMirror, ConstructorMirror, EnumMirror, FieldMirror, InterfaceMirror, MethodMirror, PropertyMirror, Type } from '@cparra/apex-reflection';
+export interface WalkerListener {
+    onTypeDeclaration(typeMirror: Type): void;
+    onConstructorDeclaration(className: string, constructors: ConstructorMirror[]): void;
+    onFieldsDeclaration(fields: FieldMirror[]): void;
+    onPropertiesDeclaration(properties: PropertyMirror[]): void;
+    onMethodsDeclaration(methods: MethodMirror[]): void;
+    onInnerEnumsDeclaration(enums: EnumMirror[]): void;
+    onInnerClassesDeclaration(classes: ClassMirror[]): void;
+    onInnerInterfacesDeclaration(interfaces: InterfaceMirror[]): void;
+}
+export declare abstract class Walker {
+    type: Type;
+    constructor(type: Type);
+    abstract walk(listener: WalkerListener): void;
+    protected sortType<T extends {
+        name: string;
+    }>(types: T[]): T[];
+}

package/lib/service/walkers/walker.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Walker = void 0;
-const settings_1 = require("../../settings");
-class Walker {
-    constructor(type) {
-        this.type = type;
-    }
-    sortType(types) {
-        if (settings_1.Settings.getInstance().sortMembersAlphabetically()) {
-            return types.sort((a, b) => a.name.localeCompare(b.name));
-        }
-        return types;
-    }
-}
-exports.Walker = Walker;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Walker = void 0;
+const settings_1 = require("../../settings");
+class Walker {
+    constructor(type) {
+        this.type = type;
+    }
+    sortType(types) {
+        if (settings_1.Settings.getInstance().sortMembersAlphabetically()) {
+            return types.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        return types;
+    }
+}
+exports.Walker = Walker;
 //# sourceMappingURL=walker.js.map