utilium 0.4.4 → 0.5.1

package/dist/fs.d.ts

@@ -0,0 +1,70 @@
+type fs = typeof import('fs');
+declare let fs: fs;
+export declare function whenDefaultFSDone(): Promise<void>;
+export declare function useFS(_fs: fs): void;
+export declare abstract class FileMap<V> implements Map<string, V> {
+    protected readonly path: string;
+    get [Symbol.toStringTag](): string;
+    constructor(path: string);
+    protected abstract readonly _map: Map<string, V>;
+    abstract clear(): void;
+    abstract delete(key: string): boolean;
+    abstract get(key: string): V;
+    abstract has(key: string): boolean;
+    abstract set(key: string, value: V): this;
+    get size(): number;
+    get [Symbol.iterator](): () => IterableIterator<[string, V]>;
+    get keys(): typeof this._map.keys;
+    get values(): typeof this._map.values;
+    get entries(): typeof this._map.entries;
+    get forEach(): typeof this._map.forEach;
+}
+export type JSONObject<Key extends string | number | symbol = string> = {
+    [K in Key]: JSONValue;
+};
+export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
+export interface JSONFileMapOptions {
+    /**
+     * Should an invalid JSON file be overwritten
+     */
+    overwrite_invalid: boolean;
+}
+/**
+ * A Map overlaying a JSON file
+ */
+export declare class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
+    readonly options: JSONFileMapOptions;
+    get [Symbol.toStringTag](): 'JSONFileMap';
+    constructor(path: string, options: JSONFileMapOptions);
+    get _map(): Map<string, T>;
+    _write(map: Map<string, T>): void;
+    clear(): void;
+    delete(key: string): boolean;
+    get<U extends T>(key: string): U;
+    has(key: string): boolean;
+    set(key: string, value: T): this;
+}
+export interface FolderMapOptions {
+    /**
+     * Suffix to append to keys to resolve file names
+     */
+    suffix: string;
+}
+/**
+ * A Map overlaying a folder
+ */
+export declare class FolderMap extends FileMap<string> {
+    readonly options: Partial<FolderMapOptions>;
+    get [Symbol.toStringTag](): 'FolderMap';
+    constructor(path: string, options: Partial<FolderMapOptions>);
+    protected get _names(): string[];
+    protected _join(path: string): string;
+    protected get _map(): Map<string, string>;
+    clear(): void;
+    delete(key: string): boolean;
+    get(key: string): string;
+    has(key: string): boolean;
+    set(key: string, value: string): this;
+}
+export declare function gitCommitHash(repo?: string): string;
+export {};

package/dist/fs.js

@@ -0,0 +1,169 @@
+import { isJSON } from './objects.js';
+let fs;
+const defaultFS = import('fs').then(_ => (fs = _));
+export async function whenDefaultFSDone() {
+    await defaultFS;
+}
+export function useFS(_fs) {
+    fs = _fs;
+}
+export class FileMap {
+    path;
+    get [Symbol.toStringTag]() {
+        return 'FileMap';
+    }
+    constructor(path) {
+        this.path = path;
+        if (!path) {
+            throw new ReferenceError('No path specified');
+        }
+        if (!fs) {
+            throw new ReferenceError('No filesystem API');
+        }
+    }
+    get size() {
+        return this._map.size;
+    }
+    get [Symbol.iterator]() {
+        return this._map[Symbol.iterator].bind(this._map);
+    }
+    get keys() {
+        return this._map.keys.bind(this._map);
+    }
+    get values() {
+        return this._map.values.bind(this._map);
+    }
+    get entries() {
+        return this._map.entries.bind(this._map);
+    }
+    get forEach() {
+        return this._map.forEach.bind(this._map);
+    }
+}
+/**
+ * A Map overlaying a JSON file
+ */
+export class JSONFileMap extends FileMap {
+    options;
+    get [Symbol.toStringTag]() {
+        return 'JSONFileMap';
+    }
+    constructor(path, options) {
+        super(path);
+        this.options = options;
+        if (!fs.existsSync(path)) {
+            fs.writeFileSync(path, '{}');
+        }
+    }
+    get _map() {
+        const content = fs.readFileSync(this.path, 'utf8');
+        if (!isJSON(content)) {
+            if (!this.options.overwrite_invalid) {
+                throw new SyntaxError('Invalid JSON file: ' + this.path);
+            }
+            console.warn('Invalid JSON file (overwriting): ' + this.path);
+            this.clear();
+            return new Map();
+        }
+        return new Map(Object.entries(JSON.parse(content)));
+    }
+    _write(map) {
+        if (!fs.existsSync(this.path)) {
+            fs.writeFileSync(this.path, '{}');
+        }
+        const content = JSON.stringify(Object.fromEntries(map));
+        fs.writeFileSync(this.path, content);
+    }
+    clear() {
+        fs.writeFileSync(this.path, '{}');
+    }
+    delete(key) {
+        const map = this._map;
+        const rt = map.delete(key);
+        this._write(map);
+        return rt;
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    set(key, value) {
+        const map = this._map;
+        map.set(key, value);
+        this._write(map);
+        return this;
+    }
+}
+/**
+ * A Map overlaying a folder
+ */
+export class FolderMap extends FileMap {
+    options;
+    get [Symbol.toStringTag]() {
+        return 'FolderMap';
+    }
+    constructor(path, options) {
+        super(path);
+        this.options = options;
+    }
+    get _names() {
+        return fs
+            .readdirSync(this.path)
+            .filter(p => p.endsWith(this.options.suffix || ''))
+            .map(p => p.slice(0, -this.options.suffix.length));
+    }
+    _join(path) {
+        return `${this.path}/${path}${this.options.suffix}`;
+    }
+    get _map() {
+        const entries = [];
+        for (const name of this._names) {
+            const content = fs.readFileSync(this._join(name), 'utf8');
+            entries.push([name, content]);
+        }
+        return new Map(entries);
+    }
+    clear() {
+        for (const name of this._names) {
+            fs.unlinkSync(this._join(name));
+        }
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            return false;
+        }
+        fs.unlinkSync(this._join(key));
+        return true;
+    }
+    get(key) {
+        if (!this.has(key)) {
+            throw new ReferenceError('Key not found');
+        }
+        return fs.readFileSync(this._join(key), 'utf8');
+    }
+    has(key) {
+        return this._names.includes(key);
+    }
+    set(key, value) {
+        fs.writeFileSync(this._join(key), value);
+        return this;
+    }
+}
+export function gitCommitHash(repo = '.') {
+    repo = repo.replaceAll(/\/+/g, '/').replaceAll(/\/$/g, '');
+    const rev = fs
+        .readFileSync(repo + '.git/HEAD')
+        .toString()
+        .trim();
+    if (rev.indexOf(':') === -1) {
+        return rev;
+    }
+    else {
+        return fs
+            .readFileSync(repo + '.git/' + rev.substring(5))
+            .toString()
+            .trim();
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './fs.js';
 export * from './list.js';
 export * from './misc.js';
 export * from './numbers.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './fs.js';
 export * from './list.js';
 export * from './misc.js';
 export * from './numbers.js';

package/dist/objects.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-import type * as FS from 'fs';
 import { UnionToTuple } from './types.js';
 export declare function filterObject<O extends object, R extends object>(object: O, predicate: (key: keyof O, value: O[keyof O]) => boolean): R;
 export declare function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Pick<T, K>;
@@ -14,74 +12,4 @@ export type Entries<T extends object> = UnionToTuple<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>;
 export declare function isJSON(str: string): boolean;
-export declare abstract class FileMap<V> implements Map<string, V> {
-    protected readonly path: string;
-    protected fs: typeof FS;
-    get [Symbol.toStringTag](): string;
-    constructor(path: string, fs: typeof FS);
-    protected abstract readonly _map: Map<string, V>;
-    abstract clear(): void;
-    abstract delete(key: string): boolean;
-    abstract get(key: string): V;
-    abstract has(key: string): boolean;
-    abstract set(key: string, value: V): this;
-    get size(): number;
-    get [Symbol.iterator](): () => IterableIterator<[string, V]>;
-    get keys(): typeof this._map.keys;
-    get values(): typeof this._map.values;
-    get entries(): typeof this._map.entries;
-    get forEach(): typeof this._map.forEach;
-}
-export type JSONObject<Key extends string | number | symbol = string> = {
-    [K in Key]: JSONValue;
-};
-export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
-export interface JSONFileMapOptions {
-    /**
-     * Should an invalid JSON file be overwritten
-     */
-    overwrite_invalid_json: boolean;
-    /**
-     * FS module
-     */
-    fs: typeof FS;
-}
-/**
- * A Map overlaying a JSON file
- */
-export declare class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
-    readonly options: JSONFileMapOptions;
-    get [Symbol.toStringTag](): 'JSONFileMap';
-    constructor(path: string, options: JSONFileMapOptions);
-    get _map(): Map<string, T>;
-    _write(map: Map<string, T>): void;
-    clear(): void;
-    delete(key: string): boolean;
-    get<U extends T>(key: string): U;
-    has(key: string): boolean;
-    set(key: string, value: T): this;
-}
-export interface FolderMapOptions {
-    /**
-     * Suffix to append to keys to resolve file names
-     */
-    suffix: string;
-    fs: typeof FS;
-}
-/**
- * A Map overlaying a folder
- */
-export declare class FolderMap extends FileMap<string> {
-    readonly options: Partial<FolderMapOptions>;
-    get [Symbol.toStringTag](): 'FolderMap';
-    constructor(path: string, options: Partial<FolderMapOptions>);
-    protected get _names(): string[];
-    protected _join(path: string): string;
-    protected get _map(): Map<string, string>;
-    clear(): void;
-    delete(key: string): boolean;
-    get(key: string): string;
-    has(key: string): boolean;
-    set(key: string, value: string): this;
-}
 export declare function resolveConstructors(object: object): string[];

package/dist/objects.js

@@ -32,152 +32,6 @@ export function isJSON(str) {
         return false;
     }
 }
-export class FileMap {
-    path;
-    fs;
-    get [Symbol.toStringTag]() {
-        return 'FileMap';
-    }
-    constructor(path, fs) {
-        this.path = path;
-        this.fs = fs;
-        if (!path) {
-            throw new ReferenceError('No path specified');
-        }
-        if (!fs) {
-            throw new ReferenceError('No filesystem API');
-        }
-    }
-    get size() {
-        return this._map.size;
-    }
-    get [Symbol.iterator]() {
-        return this._map[Symbol.iterator].bind(this._map);
-    }
-    get keys() {
-        return this._map.keys.bind(this._map);
-    }
-    get values() {
-        return this._map.values.bind(this._map);
-    }
-    get entries() {
-        return this._map.entries.bind(this._map);
-    }
-    get forEach() {
-        return this._map.forEach.bind(this._map);
-    }
-}
-/**
- * A Map overlaying a JSON file
- */
-export class JSONFileMap extends FileMap {
-    options;
-    get [Symbol.toStringTag]() {
-        return 'JSONFileMap';
-    }
-    constructor(path, options) {
-        super(path, options.fs);
-        this.options = options;
-        if (!this.fs.existsSync(path)) {
-            this.fs.writeFileSync(path, '{}');
-        }
-    }
-    get _map() {
-        const content = this.fs.readFileSync(this.path, 'utf8');
-        if (!isJSON(content)) {
-            if (!this.options.overwrite_invalid_json) {
-                throw new SyntaxError('Invalid JSON file: ' + this.path);
-            }
-            console.warn('Invalid JSON file (overwriting): ' + this.path);
-            this.clear();
-            return new Map();
-        }
-        return new Map(Object.entries(JSON.parse(content)));
-    }
-    _write(map) {
-        if (!this.fs.existsSync(this.path)) {
-            this.fs.writeFileSync(this.path, '{}');
-        }
-        const content = JSON.stringify(Object.fromEntries(map));
-        this.fs.writeFileSync(this.path, content);
-    }
-    clear() {
-        this.fs.writeFileSync(this.path, '{}');
-    }
-    delete(key) {
-        const map = this._map;
-        const rt = map.delete(key);
-        this._write(map);
-        return rt;
-    }
-    get(key) {
-        return this._map.get(key);
-    }
-    has(key) {
-        return this._map.has(key);
-    }
-    set(key, value) {
-        const map = this._map;
-        map.set(key, value);
-        this._write(map);
-        return this;
-    }
-}
-/**
- * A Map overlaying a folder
- */
-export class FolderMap extends FileMap {
-    options;
-    get [Symbol.toStringTag]() {
-        return 'FolderMap';
-    }
-    constructor(path, options) {
-        super(path, options.fs);
-        this.options = options;
-    }
-    get _names() {
-        return this.fs
-            .readdirSync(this.path)
-            .filter(p => p.endsWith(this.options.suffix || ''))
-            .map(p => p.slice(0, -this.options.suffix.length));
-    }
-    _join(path) {
-        return `${this.path}/${path}${this.options.suffix}`;
-    }
-    get _map() {
-        const entries = [];
-        for (const name of this._names) {
-            const content = this.fs.readFileSync(this._join(name), 'utf8');
-            entries.push([name, content]);
-        }
-        return new Map(entries);
-    }
-    clear() {
-        for (const name of this._names) {
-            this.fs.unlinkSync(this._join(name));
-        }
-    }
-    delete(key) {
-        if (!this.has(key)) {
-            return false;
-        }
-        this.fs.unlinkSync(this._join(key));
-        return true;
-    }
-    get(key) {
-        if (!this.has(key)) {
-            throw new ReferenceError('Key not found');
-        }
-        return this.fs.readFileSync(this._join(key), 'utf8');
-    }
-    has(key) {
-        return this._names.includes(key);
-    }
-    set(key, value) {
-        this.fs.writeFileSync(this._join(key), value);
-        return this;
-    }
-}
 export function resolveConstructors(object) {
     const constructors = [];
     let prototype = object;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.4.4",
+	"version": "0.5.1",
 	"description": "Typescript utilies",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/fs.ts

@@ -0,0 +1,234 @@
+import { isJSON } from './objects.js';
+
+type fs = typeof import('fs');
+
+let fs: fs;
+
+const defaultFS = import('fs').then(_ => (fs = _));
+
+export async function whenDefaultFSDone(): Promise<void> {
+	await defaultFS;
+}
+
+export function useFS(_fs: fs): void {
+	fs = _fs;
+}
+
+export abstract class FileMap<V> implements Map<string, V> {
+	public get [Symbol.toStringTag](): string {
+		return 'FileMap';
+	}
+
+	public constructor(protected readonly path: string) {
+		if (!path) {
+			throw new ReferenceError('No path specified');
+		}
+
+		if (!fs) {
+			throw new ReferenceError('No filesystem API');
+		}
+	}
+
+	protected abstract readonly _map: Map<string, V>;
+
+	public abstract clear(): void;
+
+	public abstract delete(key: string): boolean;
+
+	public abstract get(key: string): V;
+
+	public abstract has(key: string): boolean;
+
+	public abstract set(key: string, value: V): this;
+
+	public get size() {
+		return this._map.size;
+	}
+
+	public get [Symbol.iterator]() {
+		return this._map[Symbol.iterator].bind(this._map);
+	}
+
+	public get keys(): typeof this._map.keys {
+		return this._map.keys.bind(this._map);
+	}
+
+	public get values(): typeof this._map.values {
+		return this._map.values.bind(this._map);
+	}
+
+	public get entries(): typeof this._map.entries {
+		return this._map.entries.bind(this._map);
+	}
+
+	public get forEach(): typeof this._map.forEach {
+		return this._map.forEach.bind(this._map);
+	}
+}
+
+export type JSONObject<Key extends string | number | symbol = string> = { [K in Key]: JSONValue };
+
+export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
+
+export interface JSONFileMapOptions {
+	/**
+	 * Should an invalid JSON file be overwritten
+	 */
+	overwrite_invalid: boolean;
+}
+
+/**
+ * A Map overlaying a JSON file
+ */
+export class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
+	public get [Symbol.toStringTag](): 'JSONFileMap' {
+		return 'JSONFileMap';
+	}
+
+	public constructor(
+		path: string,
+		public readonly options: JSONFileMapOptions
+	) {
+		super(path);
+		if (!fs.existsSync(path)) {
+			fs.writeFileSync(path, '{}');
+		}
+	}
+
+	public get _map(): Map<string, T> {
+		const content = fs.readFileSync(this.path, 'utf8');
+		if (!isJSON(content)) {
+			if (!this.options.overwrite_invalid) {
+				throw new SyntaxError('Invalid JSON file: ' + this.path);
+			}
+			console.warn('Invalid JSON file (overwriting): ' + this.path);
+			this.clear();
+			return new Map();
+		}
+		return new Map(Object.entries(JSON.parse(content)));
+	}
+
+	public _write(map: Map<string, T>) {
+		if (!fs.existsSync(this.path)) {
+			fs.writeFileSync(this.path, '{}');
+		}
+		const content = JSON.stringify(Object.fromEntries(map));
+		fs.writeFileSync(this.path, content);
+	}
+
+	public clear() {
+		fs.writeFileSync(this.path, '{}');
+	}
+
+	public delete(key: string): boolean {
+		const map = this._map;
+		const rt = map.delete(key);
+		this._write(map);
+		return rt;
+	}
+
+	public get<U extends T>(key: string): U {
+		return this._map.get(key) as U;
+	}
+
+	public has(key: string): boolean {
+		return this._map.has(key);
+	}
+
+	public set(key: string, value: T): this {
+		const map = this._map;
+		map.set(key, value);
+		this._write(map);
+		return this;
+	}
+}
+
+export interface FolderMapOptions {
+	/**
+	 * Suffix to append to keys to resolve file names
+	 */
+	suffix: string;
+}
+
+/**
+ * A Map overlaying a folder
+ */
+export class FolderMap extends FileMap<string> {
+	public get [Symbol.toStringTag](): 'FolderMap' {
+		return 'FolderMap';
+	}
+
+	public constructor(
+		path: string,
+		public readonly options: Partial<FolderMapOptions>
+	) {
+		super(path);
+	}
+
+	protected get _names(): string[] {
+		return fs
+			.readdirSync(this.path)
+			.filter(p => p.endsWith(this.options.suffix || ''))
+			.map(p => p.slice(0, -this.options.suffix!.length));
+	}
+
+	protected _join(path: string): string {
+		return `${this.path}/${path}${this.options.suffix}`;
+	}
+
+	protected get _map(): Map<string, string> {
+		const entries: [string, string][] = [];
+		for (const name of this._names) {
+			const content = fs.readFileSync(this._join(name), 'utf8');
+			entries.push([name, content]);
+		}
+		return new Map(entries);
+	}
+
+	public clear(): void {
+		for (const name of this._names) {
+			fs.unlinkSync(this._join(name));
+		}
+	}
+
+	public delete(key: string): boolean {
+		if (!this.has(key)) {
+			return false;
+		}
+
+		fs.unlinkSync(this._join(key));
+		return true;
+	}
+
+	public get(key: string): string {
+		if (!this.has(key)) {
+			throw new ReferenceError('Key not found');
+		}
+		return fs.readFileSync(this._join(key), 'utf8');
+	}
+
+	public has(key: string): boolean {
+		return this._names.includes(key);
+	}
+
+	public set(key: string, value: string): this {
+		fs.writeFileSync(this._join(key), value);
+		return this;
+	}
+}
+
+export function gitCommitHash(repo: string = '.'): string {
+	repo = repo.replaceAll(/\/+/g, '/').replaceAll(/\/$/g, '');
+	const rev = fs
+		.readFileSync(repo + '.git/HEAD')
+		.toString()
+		.trim();
+	if (rev.indexOf(':') === -1) {
+		return rev;
+	} else {
+		return fs
+			.readFileSync(repo + '.git/' + rev.substring(5))
+			.toString()
+			.trim();
+	}
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './fs.js';
 export * from './list.js';
 export * from './misc.js';
 export * from './numbers.js';

package/src/objects.ts

@@ -1,4 +1,3 @@
-import type * as FS from 'fs';
 import { UnionToTuple } from './types.js';
 
 export function filterObject<O extends object, R extends object>(object: O, predicate: (key: keyof O, value: O[keyof O]) => boolean): R {
@@ -47,219 +46,6 @@ export function isJSON(str: string) {
 	}
 }
 
-export abstract class FileMap<V> implements Map<string, V> {
-	public get [Symbol.toStringTag](): string {
-		return 'FileMap';
-	}
-
-	public constructor(
-		protected readonly path: string,
-		protected fs: typeof FS
-	) {
-		if (!path) {
-			throw new ReferenceError('No path specified');
-		}
-
-		if (!fs) {
-			throw new ReferenceError('No filesystem API');
-		}
-	}
-
-	protected abstract readonly _map: Map<string, V>;
-
-	public abstract clear(): void;
-
-	public abstract delete(key: string): boolean;
-
-	public abstract get(key: string): V;
-
-	public abstract has(key: string): boolean;
-
-	public abstract set(key: string, value: V): this;
-
-	public get size() {
-		return this._map.size;
-	}
-
-	public get [Symbol.iterator]() {
-		return this._map[Symbol.iterator].bind(this._map);
-	}
-
-	public get keys(): typeof this._map.keys {
-		return this._map.keys.bind(this._map);
-	}
-
-	public get values(): typeof this._map.values {
-		return this._map.values.bind(this._map);
-	}
-
-	public get entries(): typeof this._map.entries {
-		return this._map.entries.bind(this._map);
-	}
-
-	public get forEach(): typeof this._map.forEach {
-		return this._map.forEach.bind(this._map);
-	}
-}
-
-export type JSONObject<Key extends string | number | symbol = string> = { [K in Key]: JSONValue };
-
-export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
-
-export interface JSONFileMapOptions {
-	/**
-	 * Should an invalid JSON file be overwritten
-	 */
-	overwrite_invalid_json: boolean;
-
-	/**
-	 * FS module
-	 */
-	fs: typeof FS;
-}
-
-/**
- * A Map overlaying a JSON file
- */
-export class JSONFileMap<T extends JSONValue = JSONValue> extends FileMap<T> {
-	public get [Symbol.toStringTag](): 'JSONFileMap' {
-		return 'JSONFileMap';
-	}
-
-	public constructor(
-		path: string,
-		public readonly options: JSONFileMapOptions
-	) {
-		super(path, options.fs);
-		if (!this.fs.existsSync(path)) {
-			this.fs.writeFileSync(path, '{}');
-		}
-	}
-
-	public get _map(): Map<string, T> {
-		const content = this.fs.readFileSync(this.path, 'utf8');
-		if (!isJSON(content)) {
-			if (!this.options.overwrite_invalid_json) {
-				throw new SyntaxError('Invalid JSON file: ' + this.path);
-			}
-			console.warn('Invalid JSON file (overwriting): ' + this.path);
-			this.clear();
-			return new Map();
-		}
-		return new Map(Object.entries(JSON.parse(content)));
-	}
-
-	public _write(map: Map<string, T>) {
-		if (!this.fs.existsSync(this.path)) {
-			this.fs.writeFileSync(this.path, '{}');
-		}
-		const content = JSON.stringify(Object.fromEntries(map));
-		this.fs.writeFileSync(this.path, content);
-	}
-
-	public clear() {
-		this.fs.writeFileSync(this.path, '{}');
-	}
-
-	public delete(key: string): boolean {
-		const map = this._map;
-		const rt = map.delete(key);
-		this._write(map);
-		return rt;
-	}
-
-	public get<U extends T>(key: string): U {
-		return this._map.get(key) as U;
-	}
-
-	public has(key: string): boolean {
-		return this._map.has(key);
-	}
-
-	public set(key: string, value: T): this {
-		const map = this._map;
-		map.set(key, value);
-		this._write(map);
-		return this;
-	}
-}
-
-export interface FolderMapOptions {
-	/**
-	 * Suffix to append to keys to resolve file names
-	 */
-	suffix: string;
-
-	fs: typeof FS;
-}
-
-/**
- * A Map overlaying a folder
- */
-export class FolderMap extends FileMap<string> {
-	public get [Symbol.toStringTag](): 'FolderMap' {
-		return 'FolderMap';
-	}
-
-	public constructor(
-		path: string,
-		public readonly options: Partial<FolderMapOptions>
-	) {
-		super(path, options.fs!);
-	}
-
-	protected get _names(): string[] {
-		return this.fs
-			.readdirSync(this.path)
-			.filter(p => p.endsWith(this.options.suffix || ''))
-			.map(p => p.slice(0, -this.options.suffix!.length));
-	}
-
-	protected _join(path: string): string {
-		return `${this.path}/${path}${this.options.suffix}`;
-	}
-
-	protected get _map(): Map<string, string> {
-		const entries: [string, string][] = [];
-		for (const name of this._names) {
-			const content = this.fs.readFileSync(this._join(name), 'utf8');
-			entries.push([name, content]);
-		}
-		return new Map(entries);
-	}
-
-	public clear(): void {
-		for (const name of this._names) {
-			this.fs.unlinkSync(this._join(name));
-		}
-	}
-
-	public delete(key: string): boolean {
-		if (!this.has(key)) {
-			return false;
-		}
-
-		this.fs.unlinkSync(this._join(key));
-		return true;
-	}
-
-	public get(key: string): string {
-		if (!this.has(key)) {
-			throw new ReferenceError('Key not found');
-		}
-		return this.fs.readFileSync(this._join(key), 'utf8');
-	}
-
-	public has(key: string): boolean {
-		return this._names.includes(key);
-	}
-
-	public set(key: string, value: string): this {
-		this.fs.writeFileSync(this._join(key), value);
-		return this;
-	}
-}
-
 export function resolveConstructors(object: object): string[] {
 	const constructors = [];
 	let prototype = object;