view-ignored 0.2.1 → 0.3.0

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

@@ -1,19 +1,39 @@
-import { ScanFolderOptions, Methodology } from "../lib.js";
-import { DecorConditionOptions } from "../styling.js";
+import { type ScanOptions } from '../lib.js';
+/**
+ * The target icon/logo as a {@link https://www.nerdfonts.com/ NF} icon.
+ * @public
+ */
+export type TargetIcon = {
+    /**
+     * Glyph character.
+     */
+    char: string;
+    /**
+     * The icon's color.
+     */
+    color?: number;
+};
+/**
+ * @public
+ */
+export type TargetName = string;
 /**
  * Should satisfy RegExp: `/^[-a-zA-Z0-9]+$/`.
+ * @public
  */
 export type TargetId = string;
 /**
  * @param value Target's id. Simple name.
  * @returns `true`, if the id is available for binding.
+ * @public
  */
 export declare function isTargetId(value: unknown): value is TargetId;
 /**
  * The bind which allows use predefined options for scan functions.
- * @see {@link scanProject}
+ * @see {@link scanFolder}
+ * @public
  */
-export interface TargetBind {
+export type TargetBind = {
     /**
      * Simple name.
      * @see {@link isTargetId}
@@ -22,15 +42,15 @@ export interface TargetBind {
     /**
      * Readable name.
      */
-    name: string | DecorConditionOptions;
+    name: TargetName;
     /**
-     * The walkthrough. Files including patterns.
+     * Optional icon/logo.
      */
-    methodology: Methodology[];
+    icon?: TargetIcon;
     /**
      * Folder deep scanning options for the target.
      */
-    scanOptions?: ScanFolderOptions;
+    scanOptions?: ScanOptions;
     /**
      * Test command.
      * @example
@@ -38,21 +58,24 @@ export interface TargetBind {
      * "vsce ls"
      */
     testCommand?: string;
-}
+};
 /**
  * Checks if the value is the {@link TargetBind}.
+ * @public
  */
 export declare function isTargetBind(value: unknown): value is TargetBind;
 /**
  * Allows to create targets for view-ignored scan* functions.
+ * @public
  * @example
- * scanProject("abc") // error
+ * scanFolder("abc") // error
  * Bindings.targetSet("abc", {...})
- * scanProject("abc") // ok
+ * scanFolder("abc") // ok
  */
 export declare function targetSet(bind: TargetBind): void;
 /**
  * Get all target ids.
+ * @public
  * @example
  * ["git", "npm", "vsce", ...]
  */
@@ -60,5 +83,6 @@ export declare function targetList(): string[];
 /**
  * Get target bind by target id.
  * @param id Target id.
+ * @public
  */
 export declare function targetGet(id: TargetId): TargetBind | undefined;

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

@@ -1,45 +1,37 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { isMethodology } from "../lib.js";
 /**
  * @param value Target's id. Simple name.
  * @returns `true`, if the id is available for binding.
+ * @public
  */
 export function isTargetId(value) {
-    return typeof value === "string" && value.match(/^[-a-zA-Z0-9]+$/) != null;
+    return typeof value === 'string' && (/^[-a-zA-Z\d]+$/.exec(value)) !== null;
 }
 /**
  * Checks if the value is the {@link TargetBind}.
+ * @public
  */
 export function isTargetBind(value) {
-    if (value?.constructor !== Object) {
-        return false;
-    }
-    const v = value;
-    return (isTargetId(v.id))
-        && (typeof v.name === "string" || v.name?.constructor === Object)
-        && (Array.isArray(v.methodology) && v.methodology.every(isMethodology))
-        && (v.scanOptions === undefined || v.scanOptions?.constructor === Object)
-        && (v.testCommand === undefined || typeof v.testCommand === "string");
+    return value?.constructor === Object;
 }
 /**
  * The container for binds: id=bind.
+ * @private
  */
 const targetBindMap = new Map();
 /**
  * Allows to create targets for view-ignored scan* functions.
+ * @public
  * @example
- * scanProject("abc") // error
+ * scanFolder("abc") // error
  * Bindings.targetSet("abc", {...})
- * scanProject("abc") // ok
+ * scanFolder("abc") // ok
  */
 export function targetSet(bind) {
-    if (!isTargetId(bind.id)) {
-        throw TypeError(`view-ignored can not bind target with id '${bind.id}'`);
-    }
     targetBindMap.set(bind.id, bind);
 }
 /**
  * Get all target ids.
+ * @public
  * @example
  * ["git", "npm", "vsce", ...]
  */
@@ -50,6 +42,7 @@ export function targetList() {
 /**
  * Get target bind by target id.
  * @param id Target id.
+ * @public
  */
 export function targetGet(id) {
     return targetBindMap.get(id);

package/out/src/browser/errors.d.ts

@@ -1,10 +1,61 @@
-import { Methodology } from "../lib.js";
-export declare class SomeError extends Error {
+import { type File } from './lib.js';
+/**
+ * @public
+ */
+export declare class ViewIgnoredError extends Error {
+    name: string;
 }
-export declare class ErrorNoSources extends SomeError {
-    constructor(sources?: (readonly Methodology[]) | string);
-    static walk(sources?: (readonly Methodology[]) | string): string;
+/**
+ * @public
+ */
+export declare class NoSourceError extends ViewIgnoredError {
+    static joinOr(fileBaseList: string[]): string;
+    static joinAnd(fileBaseList: string[]): string;
+    name: string;
+    /**
+     * @param fileBase Excpected message in the brackets. Describes which files was expected (e.g. 'config.json').
+     * @example
+     * new NoSourceError('\'package.json\'')
+     * new NoSourceError(NoSourceError.joinOr(['package.json', '.npmignore']))
+     * new NoSourceError(NoSourceError.joinAnd(['package.json', '.npmignore']))
+     */
+    constructor(fileBase: string);
+    /**
+     * @param file The {@link File} instance ('relativePath' property will be used).
+     */
+    constructor(file: File);
 }
-export declare class ErrorTargetNotBound extends SomeError {
-    constructor(targetId: unknown);
+/**
+ * @public
+ */
+export declare class BadSourceError extends ViewIgnoredError {
+    name: string;
+    /**
+     * @param fileBase The base of the file (e.g. 'config.json').
+     * @param message The following message after the colon. First letter uppercase, no dot.
+     * @example
+     * new BadSourceError('package.json', 'Must have name and version')
+     */
+    constructor(fileBase: string, message: string);
+    /**
+     * @param fileBase The {@link File} instance ('relativePath' property will be used).
+     * @param message The following message after the colon. First letter uppercase, no dot.
+     * @example
+     * new BadSourceError('package.json', 'Must have name and version')
+     */
+    constructor(file: File, message: string);
+}
+/**
+ * @public
+ */
+export declare class InvalidPatternError extends ViewIgnoredError {
+    name: string;
+    constructor(file: File, pattern?: string | string[]);
+}
+/**
+ * @public
+ */
+export declare class TargetNotBoundError extends ViewIgnoredError {
+    name: string;
+    constructor(targetId: string);
 }

package/out/src/browser/errors.js

@@ -1,19 +1,47 @@
-import { targetGet } from "./binds/targets.js";
-export class SomeError extends Error {
+/**
+ * @public
+ */
+export class ViewIgnoredError extends Error {
+    name = 'ViewIgnoredError';
 }
-export class ErrorNoSources extends SomeError {
-    constructor(sources) {
-        super("No available sources for methodology: " + ErrorNoSources.walk(sources));
+/**
+ * @public
+ */
+export class NoSourceError extends ViewIgnoredError {
+    static joinOr(fileBaseList) {
+        return fileBaseList.map(base => `'${base}'`).join(' or ');
     }
-    static walk(sources) {
-        const s = typeof sources === "string" ? targetGet(sources)?.methodology : sources;
-        if (!s) {
-            return `bad bind for target '${s}'`;
-        }
-        return s.map(m => `'${m.pattern}'`).join(" -> ");
+    static joinAnd(fileBaseList) {
+        return fileBaseList.map(base => `'${base}'`).join(' and ');
+    }
+    name = 'NoSourceError';
+    constructor(argument0) {
+        super(`There was no configuration file (${typeof argument0 === 'string' ? argument0 : argument0.relativePath}) in the folders and subfolders that would correctly describe the ignoring.`);
+    }
+}
+/**
+ * @public
+ */
+export class BadSourceError extends ViewIgnoredError {
+    name = 'BadSourceError';
+    constructor(argument0, message) {
+        super(`Invalid ${typeof argument0 === 'string' ? argument0 : argument0.relativePath}: ${message}`);
+    }
+}
+/**
+ * @public
+ */
+export class InvalidPatternError extends ViewIgnoredError {
+    name = 'InvalidPatternError';
+    constructor(file, pattern) {
+        super(`Invalid pattern in ${file.relativePath}: ${pattern === undefined ? '' : ` Pattern: ${JSON.stringify(pattern)}`}`);
     }
 }
-export class ErrorTargetNotBound extends SomeError {
+/**
+ * @public
+ */
+export class TargetNotBoundError extends ViewIgnoredError {
+    name = 'TargetNotBoundError';
     constructor(targetId) {
         super(`The target has no bound: '${targetId}'.`);
     }

package/out/src/browser/filtering.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Contains all filter names.
+ * @public
+ */
+export declare const filterNameList: readonly ["ignored", "included", "all"];
+/**
+ * Contains all filter names as a type.
+ * @public
+ */
+export type FilterName = typeof filterNameList[number];
+/**
+ * Checks if the value is the {@link FilterName}.
+ * @public
+ */
+export declare function isFilterName(value: unknown): value is FilterName;

package/out/src/browser/filtering.js

@@ -0,0 +1,12 @@
+/**
+ * Contains all filter names.
+ * @public
+ */
+export const filterNameList = ['ignored', 'included', 'all'];
+/**
+ * Checks if the value is the {@link FilterName}.
+ * @public
+ */
+export function isFilterName(value) {
+    return typeof value === 'string' && filterNameList.includes(value);
+}

package/out/src/browser/fs/directory.d.ts

@@ -0,0 +1,181 @@
+import { type ParsedPath } from 'node:path';
+import EventEmitter from 'node:events';
+import { type RealScanOptions } from '../lib.js';
+import { File } from './file.js';
+/**
+ * @public
+ */
+export type DeepStreamEventEmitter = EventEmitter<DeepStreamEventMap> & {
+    endPromise: Promise<DeepStreamDataRoot>;
+    run(): void;
+};
+/**
+ * @public
+ */
+export type DeepStreamDataRoot = {
+    tree: Directory;
+    progress: DeepStreamProgress;
+};
+/**
+ * @public
+ */
+export type DeepStreamData = {
+    target: Entry;
+    progress: DeepStreamProgress;
+};
+/**
+ * @public
+ */
+export type DeepStreamProgress = {
+    directories: number;
+    files: number;
+    current: number;
+    total: number;
+};
+/**
+ * @public
+ */
+export type DeepStreamEventMap = {
+    'data': [DeepStreamData];
+    'end': [DeepStreamDataRoot];
+    'progress': [DeepStreamProgress];
+};
+/**
+ * @public
+ */
+export type DeepStream = ReadableStream<Entry>;
+/**
+ * @private
+ */
+type DeepStreamNestedOptions = DeepStreamOptions & {
+    controller?: DeepStreamEventEmitter;
+    parent?: Directory;
+    progress?: DeepStreamProgress;
+};
+/**
+ * @public
+ */
+export type DeepCountOptions = Pick<DeepStreamNestedOptions, 'modules' | 'cwd' | 'concurrency' | 'progress'>;
+/**
+ * @public
+ */
+export type DeepModifiedTimeOptions = Pick<RealScanOptions, 'concurrency' | 'modules'>;
+/**
+ * @public
+ */
+export type DeepStreamOptions = Pick<RealScanOptions, 'cwd' | 'modules' | 'concurrency'>;
+/**
+ * @public
+ */
+export type Entry = Directory | File;
+/**
+ * @public
+ */
+export type EntryClass = typeof Directory | typeof File;
+/**
+ * @public
+ */
+export type EntryInstanceFrom<T extends undefined | EntryClass> = T extends undefined ? Entry : T extends typeof Directory ? Directory : File;
+/**
+ * File system directory representation.
+ * @public
+ */
+export declare class Directory implements ParsedPath {
+    /**
+     * The parent of the directory.
+     */
+    readonly parent: Directory | undefined;
+    /**
+     * The relative path to the directory.
+     */
+    readonly relativePath: string;
+    /**
+     * The absolute path to the file.
+     */
+    readonly absolutePath: string;
+    /**
+     * The content of the directory. It is a Map for performance reasons: you can find any file or folder without a loop if you know the name.
+     *
+     * Keys: {@link File.base} or {@link Directory.base}. Directory base ends with '/'.
+     *
+     * Values: {@link File} or {@link Directory} itself.
+     */
+    readonly children: Map<string, Entry>;
+    /**
+     * Get the number of directories and files.
+     * @param directoryPath Relative path to the directory.
+     * @param options The counter and reader options.
+     */
+    static deepCount(directoryPath: {
+        toString(): string;
+    }, options: DeepCountOptions): Promise<DeepStreamProgress>;
+    /**
+     * Read directories and files progressively.
+     * @param directoryPath Relative path to the directory.
+     * @param options The reader options.
+     */
+    static deepStream(directoryPath: string, optionsReal: DeepStreamOptions): DeepStreamEventEmitter;
+    /**
+     * Get the {@link Directory} instance from a file path list. Paths should be relative.
+     */
+    static from(pathList: Array<{
+        toString(): string;
+    }>, cwd?: string): Directory;
+    /**
+     * Get deep iterator for the directory.
+     */
+    static deepIterator: <T extends undefined | EntryClass>(directory: Directory, instanceOf?: T) => IterableIterator<EntryInstanceFrom<T>>;
+    /**
+     * Read directories and files progressively.
+     * @private This function should be wrapped by {@link deepStream}.
+     * @param directoryPath Relative path to the directory.
+     * @param options The reader options.
+     */
+    private static deepStreamNested;
+    readonly base: string;
+    readonly dir: string;
+    readonly ext: string;
+    readonly name: string;
+    readonly root: string;
+    constructor(
+    /**
+     * The parent of the directory.
+     */
+    parent: Directory | undefined, 
+    /**
+     * The relative path to the directory.
+     */
+    relativePath: string, 
+    /**
+     * The absolute path to the file.
+     */
+    absolutePath: string, 
+    /**
+     * The content of the directory. It is a Map for performance reasons: you can find any file or folder without a loop if you know the name.
+     *
+     * Keys: {@link File.base} or {@link Directory.base}. Directory base ends with '/'.
+     *
+     * Values: {@link File} or {@link Directory} itself.
+     */
+    children: Map<string, Entry>);
+    /**
+     * @param instanceOf Optionally filter children by type.
+     */
+    deepIterator<T extends undefined | typeof File | typeof Directory>(instanceOf?: T): IterableIterator<EntryInstanceFrom<T>>;
+    /**
+     * @param instanceOf Optionally filter children by type.
+     */
+    deep<T extends undefined | typeof File | typeof Directory>(instanceOf?: T): EntryInstanceFrom<T>[];
+    /**
+     * @returns The relative path to the directory.
+     */
+    toString(): string;
+    get<T extends string>(key: T): (T extends `${string}/` ? Directory : File) | undefined;
+    set<T extends string>(key: T, value: (T extends `${string}/` ? Directory : File)): typeof this.children;
+    /**
+     * @returns The cache for each file of the directory with last time edited number.
+     * @see {@link modified}.
+     */
+    deepModifiedTime(out: Map<File, number>, realOptions: DeepModifiedTimeOptions): Promise<Map<File, number>>;
+}
+export {};