@eagleoutice/flowr 1.4.2 → 1.5.0

package/statistics/features/feature.d.ts

@@ -1,175 +0,0 @@
-import type { EvalOptions } from 'xpath-ts2/src/parse-api';
-import type { MergeableRecord } from '../../util/objects';
-import type { NormalizedAst } from '../../r-bridge';
-import type { DataflowInformation } from '../../dataflow/internal/info';
-import type { MetaStatistics } from '../meta-statistics';
-import type { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
-/**
- * Maps each sub-feature name to the number of occurrences of that sub-feature.
- * Allows for one nesting level to denote hierarchical features.
- * <p>
- * Since we are writing to files {@link process}, we only count feature occurrences (some feature/parts are not written to file)
- */
-export type FeatureInfo = Record<string, unknown> & MergeableRecord;
-/**
- * The information and context that a {@link FeatureProcessor} may operate in.
- */
-export interface FeatureProcessorInput extends MergeableRecord {
-    /** The XML Document representing the parsed (non-normalized) R AST */
-    readonly parsedRAst: Document;
-    /** The R AST, after the normalization step */
-    readonly normalizedRAst: NormalizedAst;
-    /** The dataflow information for the given input */
-    readonly dataflow: DataflowInformation;
-    /** The filepath that the document originated from (if present, may be undefined if the input was provided as text). This can be relative to the common root directory of requests. */
-    readonly filepath: string | undefined;
-}
-/**
- * A function that processes the analysis results of a document and returns the feature information.
- */
-export type FeatureProcessor<T extends FeatureInfo> = (existing: T, input: FeatureProcessorInput) => T;
-/**
- * A feature is something to be retrieved by the statistics.
- *
- * @typeParam T - The type of what should be collected for the feature
- *
- * @see ALL_FEATURES
- */
-export interface Feature<T extends FeatureInfo> {
-    /** A descriptive, yet unique name of the feature */
-    readonly name: string;
-    /** A description of the feature */
-    readonly description: string;
-    /** A function that retrieves the feature in the document appends it to the existing feature set (we could use a monoid :D), the filepath corresponds to the active file (if any) */
-    process: FeatureProcessor<T>;
-    /**
-     * If present, this feature allows to post-process the results of the feature extraction (for the summarizer).
-     * <p>
-     * The extraction can use the output path to write files to, and should return the final output.
-     *
-     * @param featureRoot - The root path to the feature directory which should contain all the files the feature can write to (already merged for every file processed)
-     * @param info        - The feature statistic maps each file name/context encountered to the feature information as well as the meta statistics for the file
-     * @param outputPath  - The path to write the output to (besides what is collected in the output and meta information)
-     * @param config      - The configuration for the summarizer (e.g., to obtain the number of folders to skip for the feature root)
-     */
-    postProcess?: (featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration) => void;
-    /** Values to start the existing track from */
-    initialValue: T;
-}
-/**
- * The source of truth for all features that are supported by the statistics.
- */
-export declare const ALL_FEATURES: {
-    readonly usedPackages: Feature<import("ts-essentials").Writable<{
-        library: number;
-        require: number;
-        loadNamespace: number;
-        requireNamespace: number;
-        attachNamespace: number;
-        withinApply: number;
-        '::': number;
-        ':::': number;
-        '<loadedByVariable>': number;
-    }>>;
-    readonly comments: Feature<import("ts-essentials").Writable<{
-        totalAmount: number;
-        roxygenComments: number;
-        import: number;
-        importFrom: number;
-        importMethodsFrom: number;
-        importClassesFrom: number;
-        useDynLib: number;
-        export: number;
-        exportClass: number;
-        exportMethod: number;
-        exportS3Method: number;
-        exportPattern: number;
-    }>>;
-    readonly definedFunctions: Feature<import("ts-essentials").Writable<{
-        total: number;
-        lambdasOnly: number;
-        assignedFunctions: number;
-        nestedFunctions: number;
-        recursive: number;
-        deepestNesting: number;
-    }>>;
-    readonly usedFunctions: Feature<import("ts-essentials").Writable<{
-        allFunctionCalls: number;
-        args: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
-        nestedFunctionCalls: number;
-        deepestNesting: number;
-        unnamedCalls: number;
-    }>>;
-    readonly values: Feature<import("ts-essentials").Writable<{
-        allNumerics: number;
-        imaginaryNumbers: number;
-        integers: number;
-        floatHex: number;
-        logical: number;
-        specialConstants: number;
-        strings: number;
-    }>>;
-    readonly assignments: Feature<import("ts-essentials").Writable<{
-        assignmentOperator: Record<string, bigint>;
-        assigned: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        deepestNesting: number;
-        nestedOperatorAssignment: number;
-    }>>;
-    readonly loops: Feature<import("ts-essentials").Writable<{
-        forLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        forLoopVar: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        forBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        whileLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        whileBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        repeatLoops: bigint;
-        repeatBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        breakStatements: number;
-        nextStatements: number;
-        implicitLoops: number;
-        nestedExplicitLoops: number;
-        deepestExplicitNesting: number;
-    }>>;
-    readonly controlflow: Feature<import("ts-essentials").Writable<{
-        ifThen: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        thenBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        ifThenElse: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        elseBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-        nestedIfThen: number;
-        nestedIfThenElse: number;
-        deepestNesting: number;
-        switchCase: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-    }>>;
-    readonly dataAccess: Feature<import("ts-essentials").Writable<{
-        singleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
-        doubleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
-        chainedOrNestedAccess: number;
-        longestChain: number;
-        deepestNesting: number;
-        byName: number;
-        bySlot: number;
-    }>>;
-    readonly expressionList: Feature<import("ts-essentials").Writable<{
-        allExpressionLists: number;
-        deepestNesting: number;
-    }>>;
-    readonly variables: Feature<import("ts-essentials").Writable<{
-        numberOfVariableUses: number;
-        numberOfDefinitions: number;
-        numberOfRedefinitions: number;
-        unknownVariables: number;
-    }>>;
-};
-export type FeatureKey = keyof typeof ALL_FEATURES;
-export type FeatureValue<K extends FeatureKey> = ReturnType<typeof ALL_FEATURES[K]['process']>;
-/** If the user passes `all`, this should be every feature present in {@link ALL_FEATURES} (see {@link allFeatureNames})*/
-export type FeatureSelection = Set<FeatureKey>;
-export declare const allFeatureNames: Set<FeatureKey>;
-export type FeatureStatistics = {
-    [K in FeatureKey]: FeatureInfo;
-};
-export type FeatureStatisticsWithMeta = FeatureStatistics & {
-    stats: MetaStatistics;
-};
-export interface Query {
-    select(options?: EvalOptions): Node[];
-}

package/statistics/features/feature.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allFeatureNames = exports.ALL_FEATURES = void 0;
-/**
- * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
- *
- * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
- *
- * @module
- */
-const supported_1 = require("./supported");
-const variables_1 = require("./supported/variables/variables");
-/**
- * The source of truth for all features that are supported by the statistics.
- */
-exports.ALL_FEATURES = {
-    usedPackages: supported_1.usedPackages,
-    comments: supported_1.comments,
-    definedFunctions: supported_1.definedFunctions,
-    usedFunctions: supported_1.usedFunctions,
-    values: supported_1.values,
-    assignments: supported_1.assignments,
-    loops: supported_1.loops,
-    controlflow: supported_1.controlflow,
-    dataAccess: supported_1.dataAccess,
-    expressionList: supported_1.expressionList,
-    variables: variables_1.variables
-};
-exports.allFeatureNames = new Set(Object.keys(exports.ALL_FEATURES));
-//# sourceMappingURL=feature.js.map

package/statistics/features/index.d.ts

@@ -1 +0,0 @@
-export * from './feature';

package/statistics/features/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./feature"), exports);
-//# sourceMappingURL=index.js.map

package/statistics/features/post-processing.d.ts

@@ -1,12 +0,0 @@
-import type { MergeableRecord } from '../../util/objects';
-import type { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
-export interface SummarizedWithProject<Uniques = Set<string>, Count = number[]> {
-    uniqueProjects: Uniques;
-    uniqueFiles: Uniques;
-    count: Count;
-}
-export declare function emptySummarizedWithProject(): SummarizedWithProject;
-export type ReplaceKeysForSummary<Source, Target> = MergeableRecord & {
-    [K in keyof Source]: Target;
-};
-export declare function recordFilePath(summarize: SummarizedWithProject, filepath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/post-processing.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordFilePath = exports.emptySummarizedWithProject = void 0;
-const path_1 = __importDefault(require("path"));
-function emptySummarizedWithProject() {
-    return {
-        uniqueProjects: new Set(),
-        uniqueFiles: new Set(),
-        count: []
-    };
-}
-exports.emptySummarizedWithProject = emptySummarizedWithProject;
-function recordFilePath(summarize, filepath, config) {
-    summarize.uniqueFiles.add(filepath);
-    summarize.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
-}
-exports.recordFilePath = recordFilePath;
-//# sourceMappingURL=post-processing.js.map

package/statistics/features/supported/assignments/assignments.d.ts

@@ -1,11 +0,0 @@
-import type { Feature } from '../../feature';
-import type { Writable } from 'ts-essentials';
-declare const initialAssignmentInfo: {
-    assignmentOperator: Record<string, bigint>;
-    assigned: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
-    deepestNesting: number;
-    nestedOperatorAssignment: number;
-};
-export type AssignmentInfo = Writable<typeof initialAssignmentInfo>;
-export declare const assignments: Feature<AssignmentInfo>;
-export {};

package/statistics/features/supported/assignments/assignments.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assignments = void 0;
-const common_syntax_probability_1 = require("../../common-syntax-probability");
-const r_bridge_1 = require("../../../../r-bridge");
-const post_process_1 = require("./post-process");
-const initialAssignmentInfo = {
-    // operator to occurrence count
-    assignmentOperator: {},
-    assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
-    // find combinations like `` is most often used for functions?
-    deepestNesting: 0,
-    nestedOperatorAssignment: 0
-};
-function visitAssignment(info, input) {
-    const assignmentStack = [];
-    (0, r_bridge_1.visitAst)(input.normalizedRAst.ast, node => {
-        if (node.type !== "RBinaryOp" /* RType.BinaryOp */ || node.flavor !== 'assignment') {
-            return;
-        }
-        if (assignmentStack.length > 0) {
-            info.nestedOperatorAssignment++;
-            info.deepestNesting = Math.max(info.deepestNesting, assignmentStack.length);
-        }
-        assignmentStack.push(node);
-        info.assignmentOperator[node.operator] = (info.assignmentOperator[node.operator] ?? 0n) + 1n;
-        switch (node.operator) {
-            case '->':
-            case '->>':
-                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.lhs);
-                break;
-            default:
-                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.rhs);
-                break;
-        }
-    }, node => {
-        // drop again :D
-        if (node.type === "RBinaryOp" /* RType.BinaryOp */ && node.flavor === 'assignment') {
-            assignmentStack.pop();
-        }
-    });
-}
-exports.assignments = {
-    name: 'Assignments',
-    description: 'all ways to assign something in R',
-    process(existing, input) {
-        visitAssignment(existing, input);
-        return existing;
-    },
-    initialValue: initialAssignmentInfo,
-    postProcess: post_process_1.postProcess
-};
-//# sourceMappingURL=assignments.js.map

package/statistics/features/supported/assignments/index.d.ts

@@ -1 +0,0 @@
-export { assignments } from './assignments';

package/statistics/features/supported/assignments/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assignments = void 0;
-var assignments_1 = require("./assignments");
-Object.defineProperty(exports, "assignments", { enumerable: true, get: function () { return assignments_1.assignments; } });
-//# sourceMappingURL=index.js.map

package/statistics/features/supported/assignments/post-process.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureStatisticsWithMeta } from '../../feature';
-import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
-export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/assignments/post-process.js

@@ -1,125 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.postProcess = void 0;
-const common_syntax_probability_1 = require("../../common-syntax-probability");
-const numbers_1 = require("../../../../util/numbers");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const data_1 = require("../../../../util/summarizer/benchmark/data");
-const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
-const arrays_1 = require("../../../../util/arrays");
-const assert_1 = require("../../../../util/assert");
-function appendOperators(base, b, filepath, config) {
-    for (const [key, val] of Object.entries(b)) {
-        let get = base.assignmentOperator[key];
-        if (!get) {
-            get = { uniqueFiles: new Set(), uniqueProjects: new Set(), counts: [] };
-            base.assignmentOperator[key] = get;
-        }
-        const num = (0, numbers_1.bigint2number)(val);
-        get.counts.push([num]);
-        if (num > 0) {
-            get.uniqueFiles.add(filepath);
-            get.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
-        }
-    }
-}
-// returns a map that for each combination of operators found (like `<-,=`) returns the number of projects and files
-// that use both of them
-function retrieveUsageCombinationCounts(collected) {
-    const ops = Object.keys(collected.assignmentOperator);
-    if (ops.length < 1) {
-        return new Map();
-    }
-    const allCombinations = [...(0, arrays_1.getUniqueCombinationsOfSize)(ops, 1)];
-    const store = new Map();
-    for (const combs of allCombinations) {
-        if (combs.length === 1) {
-            // we can just copy the information
-            const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[0]];
-            store.set(combs[0], { uniqueProjects, uniqueFiles });
-            continue;
-        }
-        const existingKey = combs.slice(0, -1).join(',');
-        const existing = store.get(existingKey);
-        (0, assert_1.guard)(existing !== undefined, `Unable to retrieve cache for ${existingKey}`);
-        const newKey = combs.join(',');
-        const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[combs.length - 1]];
-        const newUniqueProjects = new Set([...existing.uniqueProjects].filter(x => uniqueProjects.has(x)));
-        const newUniqueFiles = new Set([...existing.uniqueFiles].filter(x => uniqueFiles.has(x)));
-        store.set(newKey, { uniqueProjects: newUniqueProjects, uniqueFiles: newUniqueFiles });
-    }
-    const result = new Map();
-    for (const [key, val] of store.entries()) {
-        result.set(key, { uniqueProjects: val.uniqueProjects.size, uniqueFiles: val.uniqueFiles.size });
-    }
-    return result;
-}
-function writeOperatorCombinationsUsageToCsv(collected, outputPath) {
-    // now to get all projects exhausted with _only_ a given subset (e.g., all projects only using '=')
-    const operators = retrieveUsageCombinationCounts(collected);
-    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned-combinations.csv'));
-    out.write('assignment,unique-projects,unique-files\n');
-    for (const [key, val] of operators.entries()) {
-        out.write(`${JSON.stringify(key)},${val.uniqueProjects},${val.uniqueFiles}\n`);
-    }
-    out.close();
-}
-function writeAssignmentMetadataToCsv(outputPath, collected) {
-    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-meta.csv'));
-    out.write(`kind,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
-    const summarizedDeepestNesting = (0, process_1.summarizeMeasurement)(collected.deepestNesting.flat());
-    out.write(`deepest-nesting,${(0, data_1.summarizedMeasurement2Csv)(summarizedDeepestNesting)}\n`);
-    const summarizedNestedOperatorAssignment = (0, process_1.summarizeMeasurement)(collected.nestedOperatorAssignment.flat());
-    out.write(`nested-operator-assignment,${(0, data_1.summarizedMeasurement2Csv)(summarizedNestedOperatorAssignment)}\n`);
-    out.close();
-}
-function writeAssignedTypesToCsv(outputPath, collected) {
-    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned.csv'));
-    out.write(`kind,name,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
-    for (const [entryName, values] of Object.entries(collected.assigned)) {
-        if (Array.isArray(values)) {
-            out.write(`${JSON.stringify(entryName)},"",${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(values.flat()))}\n`);
-        }
-        else {
-            for (const [keyName, keyValue] of Object.entries(values)) {
-                out.write(`${JSON.stringify(entryName)},${JSON.stringify(keyName)},${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(keyValue.flat()))}\n`);
-            }
-        }
-    }
-    out.close();
-}
-function writeAssignmentOperatorsToCsv(outputPath, collected) {
-    const fnOutStream = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assignment-operators.csv'));
-    fnOutStream.write(`assignment,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
-    for (const [key, val] of Object.entries(collected.assignmentOperator)) {
-        const { uniqueProjects, uniqueFiles, counts } = val;
-        const summarized = (0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(counts.flat()));
-        fnOutStream.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${summarized}\n`);
-    }
-    fnOutStream.close();
-}
-function postProcess(featureRoot, info, outputPath, config) {
-    const collected = {
-        assignmentOperator: {},
-        assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
-        deepestNesting: [],
-        nestedOperatorAssignment: []
-    };
-    for (const [filepath, data] of info.entries()) {
-        const assignmentInfo = data.assignments;
-        collected.deepestNesting.push([assignmentInfo.deepestNesting]);
-        collected.nestedOperatorAssignment.push([assignmentInfo.nestedOperatorAssignment]);
-        (0, common_syntax_probability_1.appendCommonSyntaxTypeCounter)(collected.assigned, assignmentInfo.assigned);
-        appendOperators(collected, assignmentInfo.assignmentOperator, filepath, config);
-    }
-    writeAssignmentOperatorsToCsv(outputPath, collected);
-    writeOperatorCombinationsUsageToCsv(collected, outputPath);
-    writeAssignmentMetadataToCsv(outputPath, collected);
-    writeAssignedTypesToCsv(outputPath, collected);
-}
-exports.postProcess = postProcess;
-//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/comments/comments.d.ts

@@ -1,18 +0,0 @@
-import type { Feature } from '../../feature';
-import type { Writable } from 'ts-essentials';
-export declare const initialCommentInfo: {
-    totalAmount: number;
-    roxygenComments: number;
-    import: number;
-    importFrom: number;
-    importMethodsFrom: number;
-    importClassesFrom: number;
-    useDynLib: number;
-    export: number;
-    exportClass: number;
-    exportMethod: number;
-    exportS3Method: number;
-    exportPattern: number;
-};
-export type CommentInfo = Writable<typeof initialCommentInfo>;
-export declare const comments: Feature<CommentInfo>;

package/statistics/features/supported/comments/comments.js

@@ -1,133 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.comments = exports.initialCommentInfo = void 0;
-const xpath = __importStar(require("xpath-ts2"));
-const assert_1 = require("../../../../util/assert");
-const output_1 = require("../../../output");
-const post_process_1 = require("./post-process");
-exports.initialCommentInfo = {
-    totalAmount: 0,
-    roxygenComments: 0,
-    import: 0,
-    importFrom: 0,
-    importMethodsFrom: 0,
-    importClassesFrom: 0,
-    useDynLib: 0,
-    export: 0,
-    exportClass: 0,
-    exportMethod: 0,
-    exportS3Method: 0,
-    exportPattern: 0
-};
-const commentQuery = xpath.parse('//COMMENT');
-const importRegex = /^'\s*@import\s+(?<package>\S+)/;
-const importFromRegex = /^'\s*@importFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
-const useDynLibRegex = /^'\s*@useDynLib\s+(?<package>\S+)(?<fn>( +\S+)+)?$/;
-/** we still name the classes fn, so we can reuse processing code */
-const importClassesFromRegex = /^'\s*@importClassesFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
-const importMethodsFrom = /^'\s*@importMethodsFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
-/** deliberately includes the others to get a "total" overview */
-const exportRegex = /^'\s*@export/;
-const exportS3MethodRegex = /^'\s*@exportS3Method/;
-const exportClassRegex = /^'\s*@exportClass/;
-const exportMethodRegex = /^'\s*@exportMethod/;
-const exportPatternRegex = /^'\s*@exportPattern/;
-function processRoxygenImport(existing, commentsText, filepath) {
-    const packages = commentsText.map(text => importRegex.exec(text)?.groups?.package).filter(assert_1.isNotUndefined);
-    existing.import += packages.length;
-    (0, output_1.appendStatisticsFile)(exports.comments.name, 'import', packages, filepath, true);
-}
-function processWithRegex(commentsText, existing, regex) {
-    return commentsText.map(text => regex.exec(text)).filter(assert_1.isNotNull)
-        .flatMap(match => {
-        const packageName = match.groups?.package ?? '<unknown>';
-        return (match.groups?.fn.trim().split(/\s+/) ?? []).map(fn => `${JSON.stringify(packageName)},${fn}`);
-    });
-}
-function processRoxygenImportFrom(existing, commentsText, filepath) {
-    const result = processWithRegex(commentsText, existing, importFromRegex);
-    existing.importFrom += result.length;
-    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importFrom', result, filepath, true);
-}
-function processRoxygenImportClassesFrom(existing, commentsText, filepath) {
-    const result = processWithRegex(commentsText, existing, importClassesFromRegex);
-    existing.importClassesFrom += result.length;
-    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importClassesFrom', result, filepath, true);
-}
-function processRoxygenImportMethodsFrom(existing, commentsText, filepath) {
-    const result = processWithRegex(commentsText, existing, importMethodsFrom);
-    existing.importMethodsFrom += result.length;
-    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importMethodsFrom', result, filepath, true);
-}
-function processExports(existing, comments) {
-    existing.export += comments.filter(text => exportRegex.test(text)).length;
-    existing.exportClass += comments.filter(text => exportClassRegex.test(text)).length;
-    existing.exportMethod += comments.filter(text => exportMethodRegex.test(text)).length;
-    existing.exportS3Method += comments.filter(text => exportS3MethodRegex.test(text)).length;
-    existing.exportPattern += comments.filter(text => exportPatternRegex.test(text)).length;
-}
-function processMatchForDynLib(match) {
-    const packageName = match.groups?.package ?? '<unknown>';
-    const functions = match.groups?.fn?.trim().split(/\s+/) ?? [];
-    if (functions.length === 0) {
-        return [packageName];
-    }
-    else {
-        return functions.map(fn => `${JSON.stringify(packageName)},${fn}`);
-    }
-}
-function processRoxygenUseDynLib(existing, commentsText, filepath) {
-    const result = commentsText.map(text => useDynLibRegex.exec(text))
-        .filter(assert_1.isNotNull)
-        .flatMap(processMatchForDynLib);
-    existing.useDynLib += result.length;
-    (0, output_1.appendStatisticsFile)(exports.comments.name, 'useDynLib', result, filepath, true);
-}
-exports.comments = {
-    name: 'Comments',
-    description: 'All comments that appear within the document',
-    process(existing, input) {
-        const comments = commentQuery.select({ node: input.parsedRAst }).map(node => node.textContent ?? '#')
-            .map(text => {
-            (0, assert_1.guard)(text.startsWith('#'), `unexpected comment ${text}`);
-            return text.slice(1);
-        })
-            .map(text => text.trim());
-        existing.totalAmount += comments.length;
-        const roxygenComments = comments.filter(text => text.startsWith("'"));
-        existing.roxygenComments += roxygenComments.length;
-        processRoxygenImport(existing, roxygenComments, input.filepath);
-        processRoxygenImportFrom(existing, roxygenComments, input.filepath);
-        processRoxygenUseDynLib(existing, roxygenComments, input.filepath);
-        processRoxygenImportClassesFrom(existing, roxygenComments, input.filepath);
-        processRoxygenImportMethodsFrom(existing, roxygenComments, input.filepath);
-        processExports(existing, roxygenComments);
-        return existing;
-    },
-    initialValue: exports.initialCommentInfo,
-    postProcess: post_process_1.postProcess
-};
-//# sourceMappingURL=comments.js.map

package/statistics/features/supported/comments/index.d.ts

@@ -1 +0,0 @@
-export { comments } from './comments';

package/statistics/features/supported/comments/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.comments = void 0;
-var comments_1 = require("./comments");
-Object.defineProperty(exports, "comments", { enumerable: true, get: function () { return comments_1.comments; } });
-//# sourceMappingURL=index.js.map

package/statistics/features/supported/comments/post-process.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureStatisticsWithMeta } from '../../feature';
-import type { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
-export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;