linguist-js 2.7.1 → 2.8.1

package/dist/src/helpers/load-data.d.ts

@@ -0,0 +1,4 @@
+/** Nukes unused `generated.rb` file content. */
+export declare function parseGeneratedDataFile(fileContent: string): Promise<string[]>;
+/** Load a data file from github-linguist. */
+export default function loadFile(file: string, offline?: boolean): Promise<string>;

package/dist/src/helpers/load-data.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGeneratedDataFile = parseGeneratedDataFile;
+exports.default = loadFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const cache = new node_cache_1.default({});
+async function loadWebFile(file) {
+    // Return cache if it exists
+    const cachedContent = cache.get(file);
+    if (cachedContent)
+        return cachedContent;
+    // Otherwise cache the request
+    const dataUrl = (file) => `https://raw.githubusercontent.com/github/linguist/HEAD/lib/linguist/${file}`;
+    // Load file content, falling back to the local file if the request fails
+    const fileContent = await (0, cross_fetch_1.default)(dataUrl(file)).then(data => data.text()).catch(async () => await loadLocalFile(file));
+    cache.set(file, fileContent);
+    return fileContent;
+}
+async function loadLocalFile(file) {
+    const filePath = node_path_1.default.resolve(__dirname, '../../ext', file);
+    return node_fs_1.default.promises.readFile(filePath).then(buffer => buffer.toString());
+}
+/** Nukes unused `generated.rb` file content. */
+async function parseGeneratedDataFile(fileContent) {
+    var _a;
+    return [...(_a = fileContent.match(/(?<=name\.match\(\/).+?(?=(?<!\\)\/)/gm)) !== null && _a !== void 0 ? _a : []];
+}
+/** Load a data file from github-linguist. */
+async function loadFile(file, offline = false) {
+    return offline ? loadLocalFile(file) : loadWebFile(file);
+}

package/dist/src/helpers/norm-path.d.ts

@@ -0,0 +1,2 @@
+export declare const normPath: (...inputPaths: string[]) => string;
+export declare const normAbsPath: (...inputPaths: string[]) => string;

package/dist/src/helpers/norm-path.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normAbsPath = exports.normPath = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const normPath = function normalisedPath(...inputPaths) {
+    return node_path_1.default.join(...inputPaths).replace(/\\/g, '/');
+};
+exports.normPath = normPath;
+const normAbsPath = function normalisedAbsolutePath(...inputPaths) {
+    return node_path_1.default.resolve(...inputPaths).replace(/\\/g, '/');
+};
+exports.normAbsPath = normAbsPath;

package/dist/src/helpers/parse-gitattributes.d.ts

@@ -0,0 +1,17 @@
+import * as T from '../types';
+export type FlagAttributes = {
+    'vendored': boolean | null;
+    'generated': boolean | null;
+    'documentation': boolean | null;
+    'detectable': boolean | null;
+    'binary': boolean | null;
+    'language': T.LanguageResult;
+};
+export type ParsedGitattributes = Array<{
+    glob: T.FileGlob;
+    attrs: FlagAttributes;
+}>;
+/**
+ * Parses a gitattributes file.
+ */
+export default function parseAttributes(content: string, folderRoot?: string): ParsedGitattributes;

package/dist/src/helpers/parse-gitattributes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseAttributes;
+const norm_path_1 = require("./norm-path");
+/**
+ * Parses a gitattributes file.
+ */
+function parseAttributes(content, folderRoot = '.') {
+    var _a, _b;
+    const output = [];
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.replace(/#.*/, '').trim();
+        if (!line)
+            continue;
+        const parts = line.split(/\s+/g);
+        const fileGlob = parts[0];
+        const relFileGlob = (0, norm_path_1.normPath)(folderRoot, fileGlob);
+        const attrParts = parts.slice(1);
+        const isTrue = (str) => !str.startsWith('-') && !str.endsWith('=false');
+        const isFalse = (str) => str.startsWith('-') || str.endsWith('=false');
+        const trueParts = (str) => attrParts.filter(part => part.includes(str) && isTrue(part));
+        const falseParts = (str) => attrParts.filter(part => part.includes(str) && isFalse(part));
+        const hasTrueParts = (str) => trueParts(str).length > 0;
+        const hasFalseParts = (str) => falseParts(str).length > 0;
+        const boolOrNullVal = (str) => hasTrueParts(str) ? true : hasFalseParts(str) ? false : null;
+        const attrs = {
+            'generated': boolOrNullVal('linguist-generated'),
+            'vendored': boolOrNullVal('linguist-vendored'),
+            'documentation': boolOrNullVal('linguist-documentation'),
+            'detectable': boolOrNullVal('linguist-detectable'),
+            'binary': hasTrueParts('binary') || hasFalseParts('text') ? true : hasFalseParts('binary') || hasTrueParts('text') ? false : null,
+            'language': (_b = (_a = trueParts('linguist-language').at(-1)) === null || _a === void 0 ? void 0 : _a.split('=')[1]) !== null && _b !== void 0 ? _b : null,
+        };
+        output.push({ glob: relFileGlob, attrs });
+    }
+    return output;
+}

package/dist/src/helpers/parse-gitignore.d.ts

@@ -0,0 +1 @@
+export default function parseGitignore(content: string): string[];

package/dist/src/helpers/parse-gitignore.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseGitignore;
+function parseGitignore(content) {
+    const readableData = content
+        // Remove comments unless escaped
+        .replace(/(?<!\\)#.+/g, '')
+        // Remove whitespace unless escaped
+        .replace(/(?:(?<!\\)\s)+$/g, '');
+    const arrayData = readableData.split(/\r?\n/).filter(data => data);
+    return arrayData;
+}

package/dist/src/helpers/read-file.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Read part of a file on disc.
+ * @throws 'EPERM' if the file is not readable.
+ */
+export default function readFileChunk(filename: string, onlyFirstLine?: boolean): Promise<string>;

package/dist/src/helpers/read-file.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = readFileChunk;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Read part of a file on disc.
+ * @throws 'EPERM' if the file is not readable.
+ */
+async function readFileChunk(filename, onlyFirstLine = false) {
+    const chunkSize = 100;
+    const stream = node_fs_1.default.createReadStream(filename, { highWaterMark: chunkSize });
+    let content = '';
+    for await (const data of stream) { // may throw
+        content += data.toString();
+        if (onlyFirstLine && content.includes('\n')) {
+            return content.split(/\r?\n/)[0];
+        }
+    }
+    return content;
+}

package/dist/src/helpers/walk-tree.d.ts

@@ -0,0 +1,20 @@
+import { Ignore } from 'ignore';
+interface WalkInput {
+    /** Whether this is walking the tree from the root */
+    init: boolean;
+    /** The common root absolute path of all folders being checked */
+    commonRoot: string;
+    /** The absolute path that each folder is relative to */
+    folderRoots: string[];
+    /** The absolute path of folders being checked */
+    folders: string[];
+    /** An instantiated Ignore object listing ignored files */
+    ignored: Ignore;
+}
+interface WalkOutput {
+    files: string[];
+    folders: string[];
+}
+/** Generate list of files in a directory. */
+export default function walk(data: WalkInput): WalkOutput;
+export {};

package/dist/src/helpers/walk-tree.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = walk;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const parse_gitignore_1 = __importDefault(require("./parse-gitignore"));
+const norm_path_1 = require("./norm-path");
+let allFiles;
+let allFolders;
+;
+;
+/** Generate list of files in a directory. */
+function walk(data) {
+    const { init, commonRoot, folderRoots, folders, ignored } = data;
+    // Initialise files and folders lists
+    if (init) {
+        allFiles = new Set();
+        allFolders = new Set();
+    }
+    // Walk tree of a folder
+    if (folders.length === 1) {
+        const folder = folders[0];
+        const localRoot = folderRoots[0].replace(commonRoot, '').replace(/^\//, '');
+        // Get list of files and folders inside this folder
+        const files = node_fs_1.default.readdirSync(folder).map(file => {
+            // Create path relative to root
+            const base = (0, norm_path_1.normAbsPath)(folder, file).replace(commonRoot, '.');
+            // Add trailing slash to mark directories
+            const isDir = node_fs_1.default.lstatSync(node_path_1.default.resolve(commonRoot, base)).isDirectory();
+            return isDir ? `${base}/` : base;
+        });
+        // Read and apply gitignores
+        const gitignoreFilename = (0, norm_path_1.normPath)(folder, '.gitignore');
+        if (node_fs_1.default.existsSync(gitignoreFilename)) {
+            const gitignoreContents = node_fs_1.default.readFileSync(gitignoreFilename, 'utf-8');
+            const ignoredPaths = (0, parse_gitignore_1.default)(gitignoreContents);
+            ignored.add(ignoredPaths);
+        }
+        // Add gitattributes if present
+        const gitattributesPath = (0, norm_path_1.normPath)(folder, '.gitattributes');
+        if (node_fs_1.default.existsSync(gitattributesPath)) {
+            allFiles.add(gitattributesPath);
+        }
+        // Loop through files and folders
+        for (const file of files) {
+            // Create absolute path for disc operations
+            const path = (0, norm_path_1.normAbsPath)(commonRoot, file);
+            const localPath = localRoot ? file.replace(`./${localRoot}/`, '') : file.replace('./', '');
+            // Skip if nonexistant
+            const nonExistant = !node_fs_1.default.existsSync(path);
+            if (nonExistant)
+                continue;
+            // Skip if marked in gitignore
+            const isIgnored = ignored.test(localPath).ignored;
+            if (isIgnored)
+                continue;
+            // Add absolute folder path to list
+            allFolders.add((0, norm_path_1.normAbsPath)(folder));
+            // Check if this is a folder or file
+            if (file.endsWith('/')) {
+                // Recurse into subfolders
+                allFolders.add(path);
+                walk({ init: false, commonRoot, folderRoots, folders: [path], ignored });
+            }
+            else {
+                // Add file path to list
+                allFiles.add(path);
+            }
+        }
+    }
+    // Recurse into all folders
+    else {
+        for (const i in folders) {
+            walk({ init: false, commonRoot, folderRoots: [folderRoots[i]], folders: [folders[i]], ignored });
+        }
+    }
+    // Return absolute files and folders lists
+    return {
+        files: [...allFiles].map(file => file.replace(/^\./, commonRoot)),
+        folders: [...allFolders],
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import * as T from './types';
+declare function analyse(path?: string, opts?: T.Options): Promise<T.Results>;
+declare function analyse(paths?: string[], opts?: T.Options): Promise<T.Results>;
+export default analyse;