linguist-js 2.9.1 → 3.0.0-pre

package/bin/index.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-require('../dist/cli.js');
+import '../dist/cli.js';

package/dist/analyser/classifiers/byAttributes.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byAttributes(file: T.VirtualFile, langData: LanguagesScema): string[];

package/dist/analyser/classifiers/byAttributes.js

@@ -0,0 +1,13 @@
+export default function byAttributes(file, langData) {
+    // Check manual override from gitattributes or explicit language metadata
+    const requestedLang = file.attributes?.language;
+    if (!requestedLang)
+        return [];
+    // If specified language is an alias, associate it with its full name
+    const normalizedLang = Object.keys(langData).find((lang) => {
+        const aliases = langData[lang]?.aliases ?? [];
+        return (lang.toLowerCase() === requestedLang.toLowerCase() ||
+            aliases.some((alias) => alias.toLowerCase() === requestedLang.toLowerCase()));
+    });
+    return [normalizedLang ?? requestedLang];
+}

package/dist/analyser/classifiers/byExtension.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byExtension(file: T.VirtualFile, langData: LanguagesScema): string[];

package/dist/analyser/classifiers/byExtension.js

@@ -0,0 +1,31 @@
+import { getFileExtension } from '../../program/fs/normalisedPath.js';
+function isComplexExt(ext) {
+    return /\..+\./.test(ext);
+}
+export default function byExtension(file, langData) {
+    // Check if extension is a match
+    const extension = file.extension ?? getFileExtension(file.path);
+    if (!extension)
+        return [];
+    const possible = [];
+    for (const [lang, data] of Object.entries(langData)) {
+        const extMatches = data.extensions?.filter((ext) => file.path.toLowerCase().endsWith(ext.toLowerCase()));
+        if (extMatches?.length) {
+            for (const ext of extMatches) {
+                possible.push({ ext, lang });
+            }
+        }
+    }
+    // Apply more specific extension if available
+    const hasComplexExt = possible.some((entry) => isComplexExt(entry.ext));
+    return possible
+        .filter((entry) => {
+        const complex = isComplexExt(entry.ext);
+        if (hasComplexExt && !complex)
+            return false;
+        if (!hasComplexExt && complex)
+            return false;
+        return true;
+    })
+        .map((entry) => entry.lang);
+}

package/dist/analyser/classifiers/byFilename.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byFilename(file: T.VirtualFile, langData: LanguagesScema): string[];

package/dist/analyser/classifiers/byFilename.js

@@ -0,0 +1,10 @@
+import Path from 'node:path';
+export default function byFilename(file, langData) {
+    const filename = Path.basename(file.path).toLowerCase();
+    // Check if filename is a match
+    return Object.entries(langData)
+        .flatMap(([lang, data]) => {
+        const matches = data.filenames?.some((name) => name.toLowerCase() === filename);
+        return matches ? [lang] : [];
+    });
+}

package/dist/analyser/classifiers/byHeuristics.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byHeuristics(file: T.VirtualFile, candidateLanguages: string[], heuristicsData: any, langData: LanguagesScema, opts: T.Options): string[];

package/dist/analyser/classifiers/byHeuristics.js

@@ -0,0 +1,67 @@
+import pcre from '../../program/utils/pcre.js';
+import byFilename from './byFilename.js';
+import byModeline from './byModeline.js';
+import byShebang from './byShebang.js';
+function collectPatterns(heuristic, heuristicsData) {
+    const patterns = [];
+    const add = (value) => {
+        if (!value)
+            return;
+        if (Array.isArray(value)) {
+            patterns.push(...value);
+        }
+        else {
+            patterns.push(value);
+        }
+    };
+    add(heuristic.pattern);
+    add(heuristicsData.named_patterns?.[heuristic.named_pattern]);
+    if (heuristic.and) {
+        for (const entry of heuristic.and) {
+            add(entry.pattern);
+            add(heuristicsData.named_patterns?.[entry.named_pattern]);
+        }
+    }
+    return patterns;
+}
+export default function byHeuristics(file, candidateLanguages, heuristicsData, langData, opts) {
+    // Parse heuristics if applicable
+    if (!opts.checkHeuristics || file.content === undefined)
+        return [];
+    // Skip if file has explicit association
+    if (file.attributes?.language)
+        return [];
+    if (byFilename(file, langData).length)
+        return [];
+    if (byShebang(file, langData, opts).length)
+        return [];
+    if (byModeline(file, langData, opts).length)
+        return [];
+    if (candidateLanguages.length <= 1)
+        return [];
+    const extension = file.extension ?? '';
+    for (const heuristics of heuristicsData.disambiguations ?? []) {
+        // Make sure the extension matches the current file
+        if (!heuristics.extensions.includes(extension))
+            continue;
+        // Load heuristic rules
+        for (const heuristic of heuristics.rules) {
+            // Make sure the language is not an array
+            const language = Array.isArray(heuristic.language) ? heuristic.language[0] : heuristic.language;
+            const languageGroup = langData[language]?.group;
+            const matchesLang = candidateLanguages.includes(language);
+            const matchesParent = languageGroup ? candidateLanguages.includes(languageGroup) : false;
+            // Make sure the results includes this language
+            if (!matchesLang && !matchesParent)
+                continue;
+            // Normalise heuristic data
+            const patterns = collectPatterns(heuristic, heuristicsData);
+            // Check file contents and apply heuristic patterns
+            if (!patterns.length || patterns.some((pattern) => pcre(pattern).test(file.content))) {
+                // Apply heuristics
+                return [language];
+            }
+        }
+    }
+    return [];
+}

package/dist/analyser/classifiers/byModeline.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byModeline(file: T.VirtualFile, langData: LanguagesScema, opts: T.Options): string[];

package/dist/analyser/classifiers/byModeline.js

@@ -0,0 +1,22 @@
+const modelineRegex = /-\*-|(?:syntax|filetype|ft)\s*=/;
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export default function byModeline(file, langData, opts) {
+    if (!opts.checkModeline || opts.quick)
+        return [];
+    const firstLine = file.firstLine;
+    // Check modeline declaration
+    if (!firstLine || !modelineRegex.test(firstLine))
+        return [];
+    const modelineText = firstLine.toLowerCase().split(modelineRegex)[1] ?? '';
+    // Add identified language(s)
+    return Object.entries(langData).flatMap(([lang, data]) => {
+        const safeLang = escapeRegExp(lang.toLowerCase());
+        const matchesLang = new RegExp(`\\b${safeLang}(?![\\w#+*]|-\\*-)`).test(modelineText);
+        const aliases = data.aliases ?? [];
+        const matchesAlias = aliases.some((alias) => {
+            const safeAlias = escapeRegExp(alias.toLowerCase());
+            return new RegExp(`\\b${safeAlias}(?![\\w#+*]|-\\*-)`).test(modelineText);
+        });
+        return matchesLang || matchesAlias ? [lang] : [];
+    });
+}

package/dist/analyser/classifiers/byShebang.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export default function byShebang(file: T.VirtualFile, langData: LanguagesScema, opts: T.Options): string[];

package/dist/analyser/classifiers/byShebang.js

@@ -0,0 +1,27 @@
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const categoryPriority = {
+    programming: 0,
+    markup: 1,
+    prose: 2,
+    data: 3,
+};
+export default function byShebang(file, langData, opts) {
+    if (!opts.checkShebang || opts.quick)
+        return [];
+    const firstLine = file.firstLine;
+    if (!firstLine || !firstLine.startsWith('#!'))
+        return [];
+    const matches = Object.entries(langData).flatMap(([lang, data]) => {
+        const interpreters = data.interpreters ?? [];
+        // Check for interpreter match
+        const matchesInterpretor = interpreters.some((interpreter) => new RegExp(`\\b${escapeRegExp(interpreter)}\\b`).test(firstLine));
+        return matchesInterpretor ? [lang] : [];
+    });
+    return [...new Set(matches)].sort((a, b) => {
+        const aType = langData[a]?.type;
+        const bType = langData[b]?.type;
+        const aPriority = categoryPriority[aType ?? ''] ?? 4;
+        const bPriority = categoryPriority[bType ?? ''] ?? 4;
+        return aPriority - bPriority;
+    });
+}

package/dist/analyser/index.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../types/schema.js';
+import * as T from '../types/types.js';
+export default function analyseVirtualFiles(files: T.VirtualFile[], langData: LanguagesScema, heuristicsData: unknown, opts: T.Options): T.Results;

package/dist/analyser/index.js

@@ -0,0 +1,12 @@
+import { aggregateResults } from './pipeline/aggregate.js';
+import { classifyFiles } from './pipeline/classify.js';
+import { filterFiles } from './pipeline/filter.js';
+import { resolveHeuristics } from './pipeline/heuristics.js';
+import { normaliseFiles } from './pipeline/normalise.js';
+export default function analyseVirtualFiles(files, langData, heuristicsData, opts) {
+    const normalizedFiles = normaliseFiles(files);
+    const filteredFiles = filterFiles(normalizedFiles, opts);
+    const classifications = classifyFiles(filteredFiles, langData, opts);
+    const heuristicResolutions = resolveHeuristics(filteredFiles, classifications, heuristicsData, langData, opts);
+    return aggregateResults(filteredFiles, classifications, heuristicResolutions, langData, opts);
+}

package/dist/analyser/pipeline/aggregate.d.ts

@@ -0,0 +1,2 @@
+import * as T from '../../types/types.js';
+export declare function aggregateResults(files: T.VirtualFile[], classifications: Record<string, string[]>, heuristicResolutions: Record<string, string | undefined>, langData: Record<string, unknown>, opts: T.Options): T.Results;

package/dist/analyser/pipeline/aggregate.js

@@ -0,0 +1,98 @@
+import Path from 'node:path';
+const categoryKeys = ['data', 'markup', 'programming', 'prose'];
+function pickBestLanguage(classifications) {
+    return classifications[0] ?? null;
+}
+function makeRelPath(path) {
+    let relPath = normPath(Path.relative(process.cwd(), path));
+    if (!relPath.startsWith('../') && !relPath.startsWith('./')) {
+        relPath = `./${relPath}`;
+    }
+    return relPath;
+}
+function normPath(filePath) {
+    return filePath.replace(/\\\\/g, '/');
+}
+export function aggregateResults(files, classifications, heuristicResolutions, langData, opts) {
+    const results = {
+        files: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, results: {}, alternatives: {} },
+        languages: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, results: {} },
+        unknown: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, extensions: {}, filenames: {} },
+        repository: {},
+    };
+    // Skip specified categories
+    const allowedCategories = opts.categories ?? categoryKeys;
+    const hiddenCategories = categoryKeys.filter((category) => !allowedCategories.includes(category));
+    for (const file of files) {
+        // Narrow down file associations to the best fit
+        const candidates = classifications[file.path] ?? [];
+        // If no heuristics, assign a language
+        const selectedLanguage = heuristicResolutions[file.path] ?? pickBestLanguage(candidates);
+        const alternativeLanguages = [...new Set(candidates.filter((lang) => lang !== selectedLanguage))];
+        // Assign first language as a default option
+        // List alternative languages if there are any
+        // Load language bytes size
+        const size = file.size ?? file.content?.length ?? 0;
+        // Calculate lines of code
+        const lineContent = file.content ?? '';
+        const allLines = opts.calculateLines === false ? [] : lineContent.split(/\r?\n/gm);
+        const loc = {
+            total: opts.calculateLines === false ? NaN : allLines.length,
+            content: opts.calculateLines === false ? NaN : allLines.filter((line) => line.trim().length > 0).length,
+        };
+        const outputPath = opts.relativePaths && Path.isAbsolute(file.path) ? makeRelPath(file.path) : file.path;
+        if (!selectedLanguage) {
+            const extension = file.extension || Path.extname(file.path);
+            const unknownType = extension ? 'extensions' : 'filenames';
+            const name = extension || Path.basename(file.path);
+            results.files.results[outputPath] = null;
+            results.files.bytes += size;
+            results.files.lines.total += Number.isNaN(loc.total) ? 0 : loc.total;
+            results.files.lines.content += Number.isNaN(loc.content) ? 0 : loc.content;
+            results.unknown[unknownType][name] ??= 0;
+            results.unknown[unknownType][name] += size;
+            results.unknown.bytes += size;
+            results.unknown.lines.total += loc.total || 0;
+            results.unknown.lines.content += loc.content || 0;
+            continue;
+        }
+        const languageMeta = langData[selectedLanguage];
+        const category = languageMeta?.type;
+        const allowed = !hiddenCategories.includes(category ?? 'programming') || file.attributes?.detectable === true;
+        if (!allowed) {
+            continue;
+        }
+        if (!results.repository[selectedLanguage]) {
+            results.repository[selectedLanguage] = {
+                type: languageMeta?.type ?? 'programming',
+                color: languageMeta?.color,
+            };
+            if (opts.childLanguages) {
+                results.repository[selectedLanguage].parent = languageMeta?.group;
+            }
+        }
+        results.files.results[outputPath] = selectedLanguage;
+        if (alternativeLanguages.length) {
+            results.files.alternatives[outputPath] = alternativeLanguages;
+        }
+        // Apply to files totals
+        results.files.bytes += size;
+        results.files.lines.total += Number.isNaN(loc.total) ? 0 : loc.total;
+        results.files.lines.content += Number.isNaN(loc.content) ? 0 : loc.content;
+        results.languages.results[selectedLanguage] ??= { count: 0, bytes: 0, lines: { total: 0, content: 0 } };
+        results.languages.results[selectedLanguage].count += 1;
+        results.languages.results[selectedLanguage].bytes += size;
+        results.languages.results[selectedLanguage].lines.total += Number.isNaN(loc.total) ? 0 : loc.total;
+        results.languages.results[selectedLanguage].lines.content += Number.isNaN(loc.content) ? 0 : loc.content;
+        results.languages.bytes += size;
+        results.languages.lines.total += Number.isNaN(loc.total) ? 0 : loc.total;
+        results.languages.lines.content += Number.isNaN(loc.content) ? 0 : loc.content;
+    }
+    if (opts.calculateLines === false) {
+        results.files.lines = { total: NaN, content: NaN };
+    }
+    results.files.count = Object.keys(results.files.results).length;
+    results.languages.count = Object.keys(results.languages.results).length;
+    results.unknown.count = Object.keys({ ...results.unknown.extensions, ...results.unknown.filenames }).length;
+    return results;
+}

package/dist/analyser/pipeline/classify.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export declare function classifyFiles(files: T.VirtualFile[], langData: LanguagesScema, opts: T.Options): Record<string, string[]>;

package/dist/analyser/pipeline/classify.js

@@ -0,0 +1,31 @@
+import byAttributes from '../classifiers/byAttributes.js';
+import byExtension from '../classifiers/byExtension.js';
+import byFilename from '../classifiers/byFilename.js';
+import byModeline from '../classifiers/byModeline.js';
+import byShebang from '../classifiers/byShebang.js';
+function dedupeClassifications(classifications) {
+    const seen = new Set();
+    const ordered = [];
+    for (const classification of classifications) {
+        if (!seen.has(classification)) {
+            seen.add(classification);
+            ordered.push(classification);
+        }
+    }
+    return ordered;
+}
+export function classifyFiles(files, langData, opts) {
+    const classifications = {};
+    for (const file of files) {
+        // Search each language
+        const candidates = [
+            ...byAttributes(file, langData),
+            ...byFilename(file, langData),
+            ...byShebang(file, langData, opts),
+            ...byModeline(file, langData, opts),
+            ...byExtension(file, langData),
+        ];
+        classifications[file.path] = dedupeClassifications(candidates);
+    }
+    return classifications;
+}

package/dist/analyser/pipeline/filter.d.ts

@@ -0,0 +1,2 @@
+import * as T from '../../types/types.js';
+export declare function filterFiles(files: T.VirtualFile[], opts: T.Options): T.VirtualFile[];

package/dist/analyser/pipeline/filter.js

@@ -0,0 +1,14 @@
+export function filterFiles(files, opts) {
+    return files.filter((file) => {
+        // Skip binary files
+        if (!opts.keepBinary && (file.isBinary || file.attributes?.binary === true)) {
+            return false;
+        }
+        if (!opts.keepVendored &&
+            (file.metadata?.vendored === true || file.metadata?.generated === true || file.metadata?.documentation === true)) {
+            // Skip vendored, generated, or documentation files
+            return false;
+        }
+        return true;
+    });
+}

package/dist/analyser/pipeline/heuristics.d.ts

@@ -0,0 +1,3 @@
+import { LanguagesScema } from '../../types/schema.js';
+import * as T from '../../types/types.js';
+export declare function resolveHeuristics(files: T.VirtualFile[], classifications: Record<string, string[]>, heuristicsData: unknown, langData: LanguagesScema, opts: T.Options): Record<string, string | undefined>;

package/dist/analyser/pipeline/heuristics.js

@@ -0,0 +1,12 @@
+import byHeuristics from '../classifiers/byHeuristics.js';
+export function resolveHeuristics(files, classifications, heuristicsData, langData, opts) {
+    const resolved = {};
+    for (const file of files) {
+        const candidateLanguages = classifications[file.path] ?? [];
+        const heuristicLanguage = byHeuristics(file, candidateLanguages, heuristicsData, langData, opts)[0];
+        if (heuristicLanguage) {
+            resolved[file.path] = heuristicLanguage;
+        }
+    }
+    return resolved;
+}

package/dist/analyser/pipeline/normalise.d.ts

@@ -0,0 +1,2 @@
+import * as T from '../../types/types.js';
+export declare function normaliseFiles(files: T.VirtualFile[]): T.VirtualFile[];

package/dist/analyser/pipeline/normalise.js

@@ -0,0 +1,9 @@
+import { getFileExtension } from '../../program/fs/normalisedPath.js';
+export function normaliseFiles(files) {
+    return files.map((file) => ({
+        ...file,
+        extension: file.extension ?? getFileExtension(file.path),
+        firstLine: file.firstLine ?? file.content?.split(/\r?\n/)[0],
+        size: file.size ?? file.content?.length,
+    }));
+}

package/dist/cli/output/default.d.ts

@@ -0,0 +1,3 @@
+import { OptionValues } from 'commander';
+import { Results } from '../../types/types.js';
+export default function defaultOutput(args: OptionValues, data: Results): Promise<void>;

package/dist/cli/output/default.js

@@ -0,0 +1,106 @@
+import FS from 'node:fs';
+import Path from 'node:path';
+import { normPath } from '../../program/fs/normalisedPath.js';
+import { colouredMsg, hexToRgb } from '../utils.js';
+export default async function defaultOutput(args, data) {
+    const { files, languages, unknown, repository } = data;
+    if (args.minSize) {
+        // Ignore languages with a bytes/% size less than the declared min size
+        const totalSize = languages.bytes;
+        const minSizeAmt = parseFloat(args.minSize.replace(/[a-z]+$/i, '')); // '2KB' -> 2
+        const minSizeUnit = args.minSize.replace(/^\d+/, '').toLowerCase(); // '2KB' -> 'kb'
+        const checkBytes = minSizeUnit !== 'loc'; // whether to check bytes or loc
+        const conversionFactors = {
+            ['b']: (n) => n,
+            ['kb']: (n) => n * 1e3,
+            ['mb']: (n) => n * 1e6,
+            ['%']: (n) => (n * totalSize) / 100,
+            ['loc']: (n) => n,
+        };
+        const minBytesSize = conversionFactors[minSizeUnit](+minSizeAmt);
+        const other = { count: 0, bytes: 0, lines: { total: 0, content: 0, code: 0 } };
+        // Apply specified minimums: delete language results that do not reach the threshold
+        for (const [lang, data] of Object.entries(languages.results)) {
+            const checkUnit = checkBytes ? data.bytes : data.lines.content;
+            if (checkUnit < minBytesSize) {
+                // Add to 'other' count
+                other.count++;
+                other.bytes += data.bytes;
+                other.lines.total += data.lines.total;
+                other.lines.content += data.lines.content;
+                // Remove language result
+                delete languages.results[lang];
+            }
+        }
+        if (other.bytes) {
+            languages.results['Other'] = other;
+        }
+    }
+    const sortedEntries = Object.entries(languages.results).sort((a, b) => (a[1].bytes < b[1].bytes ? +1 : -1));
+    const totalBytes = languages.bytes;
+    console.log(`\n Analysed ${files.bytes.toLocaleString()} B from ${files.count} files with linguist-js`);
+    console.log(`\n Language analysis results: \n`);
+    let count = 0;
+    if (sortedEntries.length === 0)
+        console.log(`  None`);
+    // Collate files per language
+    const filesPerLanguage = {};
+    if (args.listFiles) {
+        for (const language of Object.keys(languages.results)) {
+            filesPerLanguage[language] = [];
+        }
+        for (const [file, lang] of Object.entries(files.results)) {
+            if (lang) {
+                filesPerLanguage[lang].push(file);
+            }
+        }
+    }
+    // List parsed results
+    for (const [lang, { bytes, lines }] of sortedEntries) {
+        const colour = hexToRgb(repository[lang].color ?? '#ededed');
+        const percent = (bytes) => (bytes / (totalBytes || 1)) * 100;
+        const fmtd = {
+            index: (++count).toString().padStart(2, ' '),
+            lang: lang.padEnd(24, ' '),
+            percent: percent(bytes).toFixed(2).padStart(5, ' '),
+            bytes: bytes.toLocaleString().padStart(10, ' '),
+            loc: lines.content.toLocaleString().padStart(10, ' '),
+            icon: colouredMsg(colour, '\u2588'),
+        };
+        console.log(`  ${fmtd.index}. ${fmtd.icon} ${fmtd.lang} ${fmtd.percent}% ${fmtd.bytes} B ${fmtd.loc} LOC`);
+        // If using `listFiles` option, list all files tagged as this language
+        if (args.listFiles) {
+            console.log(); // padding
+            for (const file of filesPerLanguage[lang]) {
+                let relFile = normPath(Path.relative(Path.resolve('.'), file));
+                if (!relFile.startsWith('../')) {
+                    relFile = './' + relFile;
+                }
+                const fileStat = await FS.promises.stat(file);
+                const bytes = fileStat.size;
+                const fmtd2 = {
+                    file: relFile.padEnd(42, ' '),
+                    percent: percent(bytes).toFixed(2).padStart(5, ' '),
+                    bytes: bytes.toLocaleString().padStart(10, ' '),
+                };
+                console.log(`        ${fmtd.icon} ${fmtd2.file}  ${fmtd2.percent}% ${fmtd2.bytes} B`);
+            }
+            console.log(); // padding
+        }
+    }
+    if (!args.listFiles) {
+        console.log(); // padding
+    }
+    console.log(` Total: ${totalBytes.toLocaleString()} B`);
+    // List unknown files/extensions
+    if (unknown.bytes > 0) {
+        console.log(`\n Unknown files and extensions:`);
+        for (const [name, bytes] of Object.entries(unknown.filenames)) {
+            console.log(`  '${name}': ${bytes.toLocaleString()} B`);
+        }
+        for (const [ext, bytes] of Object.entries(unknown.extensions)) {
+            console.log(`  '*${ext}': ${bytes.toLocaleString()} B`);
+        }
+        console.log(` Total: ${unknown.bytes.toLocaleString()} B`);
+    }
+}

package/dist/cli/output/tree.d.ts

@@ -0,0 +1,3 @@
+import { OptionValues } from 'commander';
+import { Results } from '../../types/types.js';
+export default function treeOutput(args: OptionValues, data: Results): void;

package/dist/cli/output/tree.js

@@ -0,0 +1,11 @@
+export default function treeOutput(args, data) {
+    const treeParts = args.tree.split('.');
+    let nestedData = data;
+    for (const part of treeParts) {
+        if (!nestedData[part]) {
+            throw Error(`TraversalError: Key '${part}' cannot be found on output object.`);
+        }
+        nestedData = nestedData[part];
+    }
+    console.log(nestedData);
+}

package/dist/cli/runCliAnalysis.d.ts

@@ -0,0 +1,2 @@
+import { OptionValues } from 'commander';
+export default function runCliAnalysis(args: OptionValues): Promise<void>;

package/dist/cli/runCliAnalysis.js

@@ -0,0 +1,26 @@
+import analyseFs from '../entry/analyseFs.js';
+import normaliseOpts from '../input/normaliseOpts.js';
+import defaultOutput from './output/default.js';
+import treeOutput from './output/tree.js';
+const validCategories = ['data', 'programming', 'prose', 'markup'];
+export default async function runCliAnalysis(args) {
+    // Check arguments
+    if (args.categories?.some((category) => !validCategories.includes(category))) {
+        console.log(`Error: '${args.categories.join(', ')}' contains an invalid category.`);
+        console.log(`\tValid options: ${validCategories.join(', ')}.`);
+        return;
+    }
+    // Analyse language data
+    const folders = args.analyse === true ? ['.'] : args.analyse;
+    const data = await analyseFs(folders, normaliseOpts(args));
+    // Print output
+    if (!args.json) {
+        defaultOutput(args, data);
+    }
+    else if (args.tree) {
+        treeOutput(args, data);
+    }
+    else {
+        console.dir(data, { depth: null });
+    }
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function colouredMsg([r, g, b]: [number, number, number], msg: string): string;
+export declare function hexToRgb(hex: string): [number, number, number];

package/dist/cli/utils.js

@@ -0,0 +1,9 @@
+export function colouredMsg([r, g, b], msg) {
+    return `\u001B[${38};2;${r};${g};${b}m${msg}\u001b[0m`;
+}
+export function hexToRgb(hex) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return [r, g, b];
+}