@loom-io/core/dist/core/list.js

A file system wrapper for Node.js and Bun

import { DirentWrapper } from '../wrapper/dirent.js';
// type ReturnTypeTuble<T extends Array<keyof DirentWrapper>> = {
//     [K in keyof T]: DirentWrapper[T[K]] extends () => unknown ? ReturnType<DirentWrapper[T[K]]> : DirentWrapper[T[K]]
// }
export class List {
    _dirent;
    static from(listOrWrap) {
        const list = new List();
        list.add(listOrWrap);
        return list;
    }
    constructor(dir, _dirent) {
        if (dir && _dirent) {
            this._dirent = _dirent.map((p) => new DirentWrapper(dir, p));
        }
        else {
            this._dirent = [];
        }
    }
    add(listOrDirentWrapper) {
        if (listOrDirentWrapper instanceof List) {
            this._dirent.push(...listOrDirentWrapper._dirent);
        }
        else {
            this._dirent.push(...listOrDirentWrapper);
        }
    }
    concat(...lists) {
        const newList = List.from(this);
        for (const list of lists) {
            newList.add(list);
        }
        return newList;
    }
    get length() {
        return this._dirent.length;
    }
    convert(wrap) {
        if (wrap.isDirectory()) {
            return wrap.dir.subDir(wrap.name);
        }
        else {
            return wrap.dir.file(wrap.name);
        }
    }
    at(index) {
        const wrap = this._dirent[index];
        return this.convert(wrap);
    }
    first() {
        return this.at(0);
    }
    last() {
        return this.at(this.length - 1);
    }
    asArray() {
        return [...this];
    }
    filter(fn) {
        const filtered = this._dirent.filter(fn);
        return List.from(filtered);
    }
    only(type) {
        switch (type) {
            case 'files':
                return this.filter((wrap) => wrap.isFile());
            case 'dirs':
            case 'directories':
                return this.filter((wrap) => wrap.isDirectory());
        }
    }
    /**
       * @deprecated Deprecated use only instead
       */
    filterByType(direntMethod) {
        return this.filter((wrap) => wrap[direntMethod]());
    }
    // TODO: THINK ABOUT THIS
    // asStringArray(): [string][]
    // asStringArray<T extends Array<keyof DirentWrapper>, U = ReturnTypeTuble<T>[]>(...params: T): U
    // asStringArray<T extends Array<keyof DirentWrapper>, U = ReturnTypeTuble<T>[]>(...params: T): U {
    // 	if(params.length === 0) {
    // 		params.push('name');
    // 	}
    // 	return this.dirWrap.map((wrap: DirentWrapper) => {
    // 		return params.map((param) => {
    // 			if(typeof wrap[param] === 'function') {
    // 				return (wrap[param] as () => unknown)();
    // 			} else {
    // 				return wrap[param];
    // 			}
    // 		});
    // 	}) as U;
    // }
    *[Symbol.iterator]() {
        for (const wrap of this._dirent) {
            if (wrap.isDirectory()) {
                yield wrap.dir.subDir(wrap.name);
            }
            else {
                yield wrap.dir.file(wrap.name);
            }
        }
    }
    get [Symbol.toStringTag]() {
        return 'LoomList';
    }
}