not finished

packages/requirefs/src/requirefs.ts

@@ -0,0 +1,170 @@
+import * as JSZip from "jszip";
+import * as path from "path";
+import * as resolve from "resolve";
+import { Tar } from "./tarReader";
+const textDecoder = new (typeof TextDecoder === "undefined" ? require("text-encoding").TextDecoder : TextDecoder)();
+
+export interface IFileReader {
+	exists(path: string): boolean;
+	read(path: string): Uint8Array;
+}
+
+/**
+ * RequireFS allows users to require from a file system.
+ */
+export class RequireFS {
+
+	private readonly reader: IFileReader;
+	private readonly customModules: Map<string, { exports: object }>;
+	private readonly requireCache: Map<string, { exports: object }>;
+	private baseDir: string | undefined;
+
+	public constructor(reader: IFileReader) {
+		this.reader = reader;
+		this.customModules = new Map();
+		this.requireCache = new Map();
+	}
+
+	/**
+	 * Add a base-directory to nest from.
+	 */
+	public basedir(path: string): void {
+		this.baseDir = path;
+	}
+
+	/**
+	 * Provide custom modules to the require instance.
+	 */
+	// tslint:disable-next-line:no-any
+	public provide(module: string, value: any): void {
+		if (this.customModules.has(module)) {
+			throw new Error("custom module has already been registered with this name");
+		}
+
+		this.customModules.set(module, value);
+	}
+
+	public readFile(target: string, type?: "string"): string;
+	public readFile(target: string, type?: "buffer"): Buffer;
+
+	/**
+	 * Read a file and returns its contents.
+	 */
+	public readFile(target: string, type?: "string" | "buffer"): string | Buffer {
+		target = path.normalize(target);
+		const read = this.reader.read(target);
+
+		return type === "string" ? textDecoder.decode(read) : Buffer.from(read);
+	}
+
+	/**
+	 * Require a path from a file system.
+	 */
+	// tslint:disable-next-line:no-any
+	public require(target: string): any {
+		target = path.normalize(target);
+
+		return this.doRequire([target], `./${path.basename(target)}`);
+	}
+
+	/**
+	 * Do require for a caller. Needed for resolving relative paths.
+	 */
+	private doRequire(callers: string[], resolvePath: string): object {
+		if (this.customModules.has(resolvePath)) {
+			return this.customModules.get(resolvePath)!.exports;
+		}
+
+		const caller = callers[callers.length - 1];
+		const reader = this.reader;
+
+		const newRelative = this.realizePath(caller, resolvePath);
+		if (this.requireCache.has(newRelative)) {
+			return this.requireCache.get(newRelative)!.exports;
+		}
+
+		const module = {
+			exports: {},
+		};
+		this.requireCache.set(newRelative, module);
+
+		const content = textDecoder.decode(reader.read(newRelative));
+		if (newRelative.endsWith(".json")) {
+			module.exports = JSON.parse(content);
+		} else {
+			eval("'use strict'; " + content);
+		}
+
+		return module.exports;
+	}
+
+	/**
+	 * Attempts to find a module from a path
+	 */
+	private realizePath(caller: string, fullRelative: string): string {
+		const stripPrefix = (path: string): string => {
+			if (path.startsWith("/")) {
+				path = path.substr(1);
+			}
+			if (path.endsWith("/")) {
+				path = path.substr(0, path.length - 1);
+			}
+
+			return path;
+		};
+		const callerDirname = path.dirname(caller);
+		const resolvedPath = resolve.sync(fullRelative, {
+			basedir: this.baseDir ? callerDirname.startsWith(this.baseDir) ? callerDirname : path.join(this.baseDir, callerDirname) : callerDirname,
+			extensions: [".js"],
+			readFileSync: (file: string): string => {
+				return this.readFile(stripPrefix(file));
+			},
+			isFile: (file: string): boolean => {
+				return this.reader.exists(stripPrefix(file));
+			},
+		});
+
+		return stripPrefix(resolvedPath);
+	}
+
+}
+
+export const fromTar = (content: Uint8Array): RequireFS => {
+	const tar = Tar.fromUint8Array(content);
+
+	return new RequireFS({
+		exists: (path: string): boolean => {
+			return tar.files.has(path);
+		},
+		read: (path: string): Uint8Array => {
+			const file = tar.files.get(path);
+			if (!file) {
+				throw new Error(`file "${path}" not found`);
+			}
+
+			return file.read();
+		},
+	});
+};
+
+export const fromZip = (content: Uint8Array): RequireFS => {
+	const zip = new JSZip(content);
+
+	return new RequireFS({
+		exists: (fsPath: string): boolean => {
+			const file = zip.file(fsPath);
+
+			return typeof file !== "undefined" && file !== null;
+		},
+		read: (fsPath: string): Uint8Array => {
+			const file = zip.file(fsPath);
+			if (!file) {
+				throw new Error(`file "${fsPath}" not found`);
+			}
+
+			// TODO: Should refactor to allow a promise.
+			// tslint:disable-next-line no-any
+			return zip.file(fsPath).async("uint8array") as any;
+		},
+	});
+};