view-ignored 0.2.1 → 0.3.0

package/out/src/browser/binds/plugins/npm.js

@@ -1,71 +1,137 @@
-import getValue from "get-value";
-export const id = "npm";
-export const name = "NPM";
-export const testCommand = "npm pack --dry-run";
+import { icons } from '@m234/nerd-fonts';
+import { Directory, InvalidPatternError, BadSourceError, NoSourceError, } from '../../index.js';
+import { ScannerGitignore } from '../scanner.js';
+import * as git from './git.js';
+const id = 'npm';
+const name = 'NPM';
+const icon = { ...icons['nf-seti-npm'], color: 0xCA_04_04 };
+const testCommand = 'npm pack --dry-run';
+/**
+ * @private
+ */
 export const matcherExclude = [
-    'node_modules/**',
-    '.*.swp',
-    '._*',
-    '.DS_Store/**',
-    '.git/**',
-    '.gitignore',
-    '.hg/**',
-    '.npmignore',
-    '.npmrc',
-    '.lock-wscript',
-    '.svn/**',
-    '.wafpickle-*',
-    'config.gypi',
-    'CVS/**',
-    'npm-debug.log',
+    ...git.matcherExclude,
+    '**/node_modules/**',
+    '**/.*.swp',
+    '**/._*',
+    '**/.DS_Store/**',
+    '**/.git/**',
+    '**/.gitignore',
+    '**/.hg/**',
+    '**/.npmignore',
+    '**/.npmrc',
+    '**/.lock-wscript',
+    '**/.svn/**',
+    '**/.wafpickle-*',
+    '**/config.gypi',
+    '**/CVS/**',
+    '**/npm-debug.log',
 ];
+/**
+ * @private
+ */
 export const matcherInclude = [
-    '/bin/',
-    '/package.json',
-    '/README',
-    '/README.*',
-    '/LICENSE',
-    '/LICENSE.*',
-    '/LICENCE',
-    '/LICENCE.*',
+    'bin/**',
+    'package.json',
+    'README*',
+    'LICENSE*',
+    'LICENCE*',
 ];
-export const scanGit = function (data) {
-    const { scanner, content } = data;
-    const pat = content?.toString();
-    if (!scanner.patternIsValid(pat)) {
+/**
+ * @private
+ */
+export function isValidManifest(value) {
+    if (value?.constructor !== Object) {
         return false;
     }
-    scanner.add(pat);
-    return true;
-};
-export const scanPackageJsonFiles = function (data) {
-    const { scanner, content } = data;
-    let parsed;
-    try {
-        const pat = content?.toString();
-        if (!pat) {
-            return false;
+    const value_ = value;
+    return ('name' in value_ && typeof value_.name === 'string')
+        && ('version' in value_ && typeof value_.version === 'string')
+        && (value_.files === undefined || (Array.isArray(value_.files) && value_.files.every(element => typeof element === 'string')));
+}
+/**
+ * @private
+ */
+export function useChildren(tree, map, getMap) {
+    for (const child of Array.from(tree.children.values())) {
+        if (!(child instanceof Directory)) {
+            continue;
         }
-        const json = JSON.parse(pat);
-        if (json?.constructor !== Object) {
-            return false;
+        const submap = getMap(child);
+        for (const [key, value] of submap.entries()) {
+            map.set(key, value);
         }
-        parsed = json;
     }
-    catch {
-        return false;
+    return map;
+}
+/**
+ * @private
+ */
+export const sourceSearch = (priority, scanner) => function (tree, o) {
+    const map = new Map();
+    for (const element of priority) {
+        const sourceFile = tree.get(element);
+        if (sourceFile === undefined) {
+            continue;
+        }
+        if (sourceFile.base === 'package.json') {
+            const manifest = JSON.parse(o.modules.fs.readFileSync(sourceFile.absolutePath).toString());
+            if (!isValidManifest(manifest)) {
+                throw new BadSourceError(sourceFile, 'Must have \'name\', \'version\' and \'files\'.');
+            }
+            const { files: pattern } = manifest;
+            if (pattern === undefined) {
+                continue;
+            }
+            if (!scanner.isValid(pattern)) {
+                throw new BadSourceError(sourceFile, `Invalid pattern, got ${JSON.stringify(pattern)}`);
+            }
+            scanner.negated = true;
+            scanner.pattern = pattern;
+        }
+        else {
+            const content = o.modules.fs.readFileSync(sourceFile.absolutePath).toString();
+            const pattern = content;
+            if (!scanner.isValid(pattern)) {
+                throw new InvalidPatternError(sourceFile, pattern);
+            }
+            scanner.negated = false;
+            scanner.pattern = pattern;
+        }
+        return git.useSourceFile(map, sourceFile, scanner);
     }
-    const propVal = getValue(parsed, "files");
-    if (!scanner.patternIsValid(propVal)) {
-        return false;
+    return useChildren(tree, map, child => sourceSearch(priority, scanner)(child, o));
+};
+/**
+ * @param priority The list of file names from highest to lowest priority.
+ * @param scanner The pattern scanner.
+ * @private
+ */
+export const methodologyManifestNpmLike = (priority, scanner) => function (tree, o) {
+    const packageJson = tree.get('package.json');
+    if (packageJson === undefined) {
+        throw new NoSourceError('\'package.json\' in the root');
     }
-    scanner.add(propVal);
-    return true;
+    const packageJsonContent = o.modules.fs.readFileSync(packageJson.absolutePath).toString();
+    let manifest;
+    try {
+        manifest = JSON.parse(packageJsonContent);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new BadSourceError(packageJson, error.message);
+        }
+        throw error;
+    }
+    if (!isValidManifest(manifest)) {
+        throw new BadSourceError(packageJson, 'Must have \'name\', \'version\' and \'files\'.');
+    }
+    return sourceSearch(priority, scanner)(tree, o);
 };
-export const methodology = [
-    { pattern: ["**/package.json"], matcherNegated: true, matcher: "gitignore", scan: scanPackageJsonFiles, matcherInclude, matcherExclude },
-    { pattern: ["**/.npmignore"], matcher: "gitignore", scan: scanGit, matcherInclude, matcherExclude },
-    { pattern: ["**/.gitignore"], matcher: "gitignore", scan: scanGit, matcherInclude, matcherExclude },
-];
-const bind = { id, name, methodology, testCommand };
-export default { viewignored: { addTargets: [bind] } };
+const bind = {
+    id, icon, name, testCommand, scanOptions: {
+        target: methodologyManifestNpmLike(['package.json', '.npmignore', '.gitignore'], new ScannerGitignore({ exclude: matcherExclude, include: matcherInclude })),
+    },
+};
+const npm = { viewignored: { addTargets: [bind] } };
+export default npm;

package/out/src/browser/binds/plugins/vsce.d.ts

@@ -1,9 +1,25 @@
-import { Plugins, ScanMethod, Methodology } from "../../index.js";
-export declare const id = "vsce";
-export declare const name = "VSC Extension";
-export declare const testCommand = "vsce ls";
+import { type Plugins, type Methodology } from '../../index.js';
+/**
+ * @private
+ */
 export declare const matcherExclude: string[];
-export declare const scan: ScanMethod;
-export declare const methodology: Methodology[];
-declare const _default: Plugins.PluginExport;
-export default _default;
+/**
+ * @private
+ */
+export type ValidManifestVsce = {
+    name: string;
+    version: string;
+    engines: {
+        vscode: string;
+    };
+};
+/**
+ * @private
+ */
+export declare function isValidManifest(value: unknown): value is ValidManifestVsce;
+/**
+ * @private
+ */
+export declare const methodologyManifestVsce: Methodology;
+declare const vsce: Plugins.PluginExport;
+export default vsce;

package/out/src/browser/binds/plugins/vsce.js

@@ -1,21 +1,61 @@
-export const id = "vsce";
-export const name = "VSC Extension";
-export const testCommand = "vsce ls";
+import { icons } from '@m234/nerd-fonts';
+import { NoSourceError, File, BadSourceError, } from '../../index.js';
+import * as git from './git.js';
+const id = 'vsce';
+const name = 'VSCE';
+const icon = { ...icons['nf-md-microsoft_visual_studio_code'], color: 0x23_A9_F1 };
+const testCommand = 'vsce ls';
+/**
+ * @private
+ */
 export const matcherExclude = [
-    ".git/**",
-    ".DS_Store/**"
+    ...git.matcherExclude,
 ];
-export const scan = function (data) {
-    const { scanner, content } = data;
-    const pat = content?.toString();
-    if (!scanner.patternIsValid(pat)) {
+/**
+ * @private
+ */
+export function isValidManifest(value) {
+    if (value?.constructor !== Object) {
         return false;
     }
-    scanner.add(pat);
-    return true;
+    const value_ = value;
+    const isManifestBase = ('name' in value_ && typeof value_.name === 'string')
+        && ('version' in value_ && typeof value_.version === 'string')
+        && ('engines' in value_ && value_.engines?.constructor === Object);
+    if (!isManifestBase) {
+        return false;
+    }
+    const { engines } = value;
+    return 'vscode' in engines && typeof engines.vscode === 'string';
+}
+/**
+ * @private
+ */
+export const methodologyManifestVsce = function (tree, o) {
+    const packageJson = Array.from(tree.deepIterator()).find(dirent => dirent instanceof File && dirent.base === 'package.json');
+    if (packageJson === undefined) {
+        throw new NoSourceError('package.json');
+    }
+    const packageJsonContent = o.modules.fs.readFileSync(packageJson.absolutePath).toString();
+    let manifest;
+    try {
+        manifest = JSON.parse(packageJsonContent);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new BadSourceError(packageJson, error.message);
+        }
+        throw error;
+    }
+    if (!isValidManifest(manifest)) {
+        throw new BadSourceError(packageJson, 'Must have name, version and engines->vscode.');
+    }
+    return git.methodologyGitignoreLike('.vscodeignore')(tree, o);
 };
-export const methodology = [
-    { pattern: "**/.vscodeignore", matcher: "minimatch", scan, matcherExclude },
-];
-const bind = { id, name, methodology, testCommand };
-export default { viewignored: { addTargets: [bind] } };
+const bind = {
+    id, icon, name, testCommand, scanOptions: {
+        target: methodologyManifestVsce,
+    },
+};
+const vsce = { viewignored: { addTargets: [bind] } };
+export default vsce;

package/out/src/browser/binds/plugins/yarn.d.ts

@@ -1,16 +1,11 @@
-import { Plugins, Methodology, ScanMethod } from "../../index.js";
-export declare const id = "yarn";
-export declare const name = "Yarn";
+import { type Plugins } from '../../index.js';
 /**
- * [!WARNING] All patterns copied from npm plugin, so they should be verified with yarn docs.
+ * @private
  */
 export declare const matcherExclude: string[];
 /**
- * [!WARNING] All patterns copied from npm plugin, so they should be verified with yarn docs.
+ * @private
  */
 export declare const matcherInclude: string[];
-export declare const scanGit: ScanMethod;
-export declare const scanPackageJsonFiles: ScanMethod;
-export declare const methodology: Methodology[];
-declare const _default: Plugins.PluginExport;
-export default _default;
+declare const yarn: Plugins.PluginExport;
+export default yarn;

package/out/src/browser/binds/plugins/yarn.js

@@ -1,78 +1,28 @@
-import getValue from "get-value";
-export const id = "yarn";
-export const name = "Yarn";
+import { icons } from '@m234/nerd-fonts';
+import { ScannerGitignore } from '../scanner.js';
+import * as npm from './npm.js';
+const id = 'yarn';
+const name = 'Yarn';
+const icon = { ...icons['nf-seti-yarn'], color: 0x2E_2A_65 };
+// FIXME: Yarn can all this stuff another way.
 /**
- * [!WARNING] All patterns copied from npm plugin, so they should be verified with yarn docs.
+ * @private
  */
 export const matcherExclude = [
-    'node_modules/**',
-    '.*.swp',
-    '._*',
-    '.DS_Store/**',
-    '.git/**',
-    '.gitignore',
-    '.hg/**',
+    ...npm.matcherExclude,
     '.yarnignore',
-    '.npmignore',
-    '.npmrc',
-    '.lock-wscript',
-    '.svn/**',
-    '.wafpickle-*',
-    'config.gypi',
-    'CVS/**',
-    'npm-debug.log',
+    '.yarnrc',
 ];
 /**
- * [!WARNING] All patterns copied from npm plugin, so they should be verified with yarn docs.
+ * @private
  */
 export const matcherInclude = [
-    '/bin/',
-    '/package.json',
-    '/README',
-    '/README.*',
-    '/LICENSE',
-    '/LICENSE.*',
-    '/LICENCE',
-    '/LICENCE.*',
+    ...npm.matcherInclude,
 ];
-export const scanGit = function (data) {
-    const { scanner, content } = data;
-    const pat = content?.toString();
-    if (!scanner.patternIsValid(pat)) {
-        return false;
-    }
-    scanner.add(pat);
-    return true;
+const bind = {
+    id, icon, name, scanOptions: {
+        target: npm.methodologyManifestNpmLike(['package.json', '.yarnignore', '.npmignore', '.gitignore'], new ScannerGitignore({ exclude: matcherExclude, include: matcherInclude })),
+    },
 };
-export const scanPackageJsonFiles = function (data) {
-    const { scanner, content } = data;
-    let parsed;
-    try {
-        const pat = content?.toString();
-        if (!pat) {
-            return false;
-        }
-        const json = JSON.parse(pat);
-        if (json?.constructor !== Object) {
-            return false;
-        }
-        parsed = json;
-    }
-    catch {
-        return false;
-    }
-    const propVal = getValue(parsed, "files");
-    if (!scanner.patternIsValid(propVal)) {
-        return false;
-    }
-    scanner.add(propVal);
-    return true;
-};
-export const methodology = [
-    { pattern: "**/package.json", matcherNegated: true, matcher: "gitignore", scan: scanPackageJsonFiles, matcherInclude, matcherExclude },
-    { pattern: "**/.yarnignore", matcher: "gitignore", scan: scanGit, matcherInclude, matcherExclude },
-    { pattern: "**/.npmignore", matcher: "gitignore", scan: scanGit, matcherInclude, matcherExclude },
-    { pattern: "**/.gitignore", matcher: "gitignore", scan: scanGit, matcherInclude, matcherExclude },
-];
-const bind = { id, name, methodology };
-export default { viewignored: { addTargets: [bind] } };
+const yarn = { viewignored: { addTargets: [bind] } };
+export default yarn;

package/out/src/browser/binds/scanner.d.ts

@@ -0,0 +1,56 @@
+import { type Scanner } from '../lib.js';
+/**
+ * @public
+ */
+export type PatternScannerOptions = {
+    pattern?: string | string[];
+    exclude?: string | string[];
+    include?: string | string[];
+    negated?: boolean;
+};
+/**
+ * @public
+ */
+export type PatternScanner = Scanner & {
+    pattern: string | string[];
+    exclude: string | string[];
+    include: string | string[];
+    negated: boolean;
+    isValid(value: unknown): value is string | string[];
+    ignores(path: string, pattern: string | string[]): boolean;
+    ignores(path: string, options?: PatternScannerOptions): boolean;
+    ignores(path: string, argument?: PatternScannerOptions | string | string[]): boolean;
+};
+/**
+ * @public
+ */
+export declare class ScannerMinimatch implements PatternScanner {
+    negated: boolean;
+    protected _pattern: string | string[];
+    get pattern(): string | string[];
+    set pattern(value: string | string[]);
+    protected _exclude: string | string[];
+    get exclude(): string | string[];
+    set exclude(value: string | string[]);
+    protected _include: string | string[];
+    get include(): string | string[];
+    set include(value: string | string[]);
+    constructor(options?: PatternScannerOptions);
+    isValid(value: unknown): value is string | string[];
+    ignores(path: string, pattern: string | string[]): boolean;
+    ignores(path: string, options?: PatternScannerOptions): boolean;
+}
+/**
+ * @public
+ */
+export declare class ScannerGitignore extends ScannerMinimatch {
+    private static gitignoreToMinimatch;
+    constructor(options?: PatternScannerOptions);
+    isValid(value: unknown): value is string | string[];
+    get pattern(): string | string[];
+    set pattern(value: string | string[]);
+    get include(): string | string[];
+    set include(value: string | string[]);
+    get exclude(): string | string[];
+    set exclude(value: string | string[]);
+}

package/out/src/browser/binds/scanner.js

@@ -0,0 +1,134 @@
+import { minimatch } from 'minimatch';
+import { gitignoreToMinimatch } from '@humanwhocodes/gitignore-to-minimatch';
+/**
+ * @public
+ */
+export class ScannerMinimatch {
+    negated;
+    _pattern;
+    get pattern() {
+        return this.pattern;
+    }
+    set pattern(value) {
+        this._pattern = value;
+    }
+    _exclude;
+    get exclude() {
+        return this._exclude;
+    }
+    set exclude(value) {
+        this._exclude = value;
+    }
+    _include;
+    get include() {
+        return this._include;
+    }
+    set include(value) {
+        this._include = value;
+    }
+    constructor(options) {
+        this._pattern = options?.pattern ?? [];
+        this._exclude = options?.exclude ?? [];
+        this._include = options?.include ?? [];
+        this.negated = options?.negated ?? false;
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(p => !Array.isArray(p) && this.isValid(value));
+        }
+        if (typeof value !== 'string') {
+            return false;
+        }
+        try {
+            minimatch.makeRe(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    ignores(path, argument) {
+        if (Array.isArray(argument)) {
+            argument = argument.join('\n');
+        }
+        if (typeof argument === 'string') {
+            const patternList = argument.split(/\r?\n/);
+            const someMatch = patternList.some(pattern => minimatch(path, pattern, { dot: true, matchBase: true }));
+            return someMatch;
+        }
+        let check;
+        check = this.ignores(path, argument?.exclude ?? this.exclude);
+        if (check) {
+            return true;
+        }
+        check = this.ignores(path, argument?.include ?? this.include);
+        if (check) {
+            return false;
+        }
+        check = this.ignores(path, argument?.pattern ?? this.pattern);
+        return (argument?.negated ?? this.negated) ? !check : check;
+    }
+}
+/**
+ * @public
+ */
+export class ScannerGitignore extends ScannerMinimatch {
+    static gitignoreToMinimatch(argument) {
+        if (typeof argument === 'string') {
+            return ScannerGitignore.gitignoreToMinimatch(argument.split(/\r?\n/)).join('\n');
+        }
+        return argument
+            .map(p => p.replaceAll(/(#.+$|(?<!\\) )/gm, ''))
+            .filter(s => s !== '')
+            .map(p => gitignoreToMinimatch(p));
+    }
+    constructor(options) {
+        const newOptions = { ...options };
+        for (const key of ['pattern', 'exclude', 'include']) {
+            const value = newOptions[key];
+            if (!Object.hasOwn(newOptions, key) || value === undefined) {
+                continue;
+            }
+            const newPattern = ScannerGitignore.gitignoreToMinimatch(value);
+            newOptions[key] = newPattern;
+        }
+        super(options);
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(p => !Array.isArray(p) || this.isValid(value));
+        }
+        if (typeof value !== 'string') {
+            return false;
+        }
+        try {
+            const converted = ScannerGitignore.gitignoreToMinimatch(value);
+            minimatch.makeRe(converted);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    get pattern() {
+        return this._pattern;
+    }
+    set pattern(value) {
+        const newPattern = ScannerGitignore.gitignoreToMinimatch(value);
+        this._pattern = newPattern;
+    }
+    get include() {
+        return this._include;
+    }
+    set include(value) {
+        const newPattern = ScannerGitignore.gitignoreToMinimatch(value);
+        this._include = newPattern;
+    }
+    get exclude() {
+        return this._exclude;
+    }
+    set exclude(value) {
+        const newPattern = ScannerGitignore.gitignoreToMinimatch(value);
+        this._exclude = newPattern;
+    }
+}