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;

},

});

};