js-dos 8.1.4 → 8.1.6

package/src/sockdrive/js/src/sockdrive-fat.d.ts

@@ -1,64 +0,0 @@
-interface Stats {
-    read: number,
-    write: number,
-    readTotalTime: number,
-    cacheHit: number,
-    cacheMiss: number,
-    cacheUsed: number,
-}
-interface StatsBase<T> {
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isSymbolicLink(): boolean;
-    isFIFO(): boolean;
-    isSocket(): boolean;
-    dev: T;
-    ino: T;
-    mode: T;
-    nlink: T;
-    uid: T;
-    gid: T;
-    rdev: T;
-    size: T;
-    blksize: T;
-    blocks: T;
-    atimeMs: T;
-    mtimeMs: T;
-    ctimeMs: T;
-    birthtimeMs: T;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-}
-interface Stats extends StatsBase<number> { }
-type FileDescriptor = number;
-export interface SockdriveInstance {
-    stats: Stats,
-    fs: {
-        mkdir: (path: string) => Promise<void>,
-        readdir: (path: string) => Promise<string[]>,
-        fopen: (path: string, flags: string | number, mode: number) => Promise<FileDescriptor>,
-        fread: (fd: FileDescriptor, buf: Uint8Array, offset: number,
-            length: number, pos: number | null) => Promise<number>,
-        fwrite: (fd: FileDescriptor, buf: Uint8Array, offset: number,
-            length: number, pos: number | null) => Promise<number>,
-        fstat: (fd: FileDescriptor) => Promise<Stats>,
-        fclose: (fd: FileDescriptor) => Promise<void>,
-        stat: (path: string) => Promise<Stats>,
-        isdir: (path: string) => Promise<boolean>,
-        exists: (path: string) => Promise<boolean>,
-    }
-    close: () => void,
-}
-
-export type CreateSockdriveFileSystem = (
-    endpoint: string,
-    ownerId: string,
-    driveId: string,
-    token: string,
-    onOpen: (read: boolean, write: boolean) => void,
-    onError: (e: Error) => void
-) => Promise<SockdriveInstance>;

package/src/sockdrive/js/src/sockdrive-fat.ts

@@ -1,226 +0,0 @@
-import { createFileSystem } from "./fatfs";
-
-const toBuffer = require("typedarray-to-buffer");
-import { Drive } from "./sockdrive/drive";
-import { EmModule, Stats as SockdriveStats } from "./sockdrive/types";
-
-export interface Driver {
-    sectorSize: number,
-    numSectors: number,
-    readSectors: (sector: number, dst: Uint8Array, cb: (error: Error | null, dst: Uint8Array) => void) => void,
-    writeSectors: (sector: number, src: Uint8Array, cb: (error: Error | null) => void) => void,
-}
-
-type Callback = (error: Error | null) => void;
-type CallbackT<T> = (error: Error | null, t: T) => void;
-
-export type FileDescriptor = number;
-
-export interface FileSystemApi {
-    mkdir(path: string, cb: Callback): void;
-    readdir(path: string, cb: CallbackT<string[]>): void;
-    open(path: string, flags: string | number, mode: number, cb: CallbackT<FileDescriptor>): void;
-    read(fd: FileDescriptor, buf: Buffer, offset: number,
-        length: number, pos: number | null, cb: CallbackT<number>): void;
-    write(fd: FileDescriptor, buf: Buffer, offset: number,
-        length: number, pos: number | null, cb: CallbackT<number>): void;
-    fstat(fd: FileDescriptor, cb: CallbackT<Stats>): void;
-    close(fd: FileDescriptor, cb: Callback): void;
-}
-
-export type CreateFileSystemApi = (driver: Driver, opts: {
-    ro?: boolean,
-    noatime?: boolean,
-    modmode?: number,
-    umask?: number,
-    uid?: number,
-    gid?: number,
-}, event: (event: "ready" | "error", reason: Error | null) => void) => FileSystemApi;
-export type CreateSockdriveFileSystem = typeof createSockdriveFileSystem;
-
-
-export class FileSystem {
-    fs: FileSystemApi;
-    constructor(fs: FileSystemApi) {
-        this.fs = fs;
-    }
-
-    private promisify<T>(fn: any, ...args: any[]): Promise<T> {
-        return new Promise<T>((resolve, reject) => {
-            fn.call(this.fs, ...args, (err: Error | null, res: T) => {
-                if (!err) {
-                    resolve(res);
-                } else {
-                    reject(err);
-                }
-            });
-        });
-    }
-
-    mkdir(path: string) {
-        return this.promisify<void>(this.fs.mkdir, path);
-    }
-    readdir(path: string) {
-        return this.promisify<string[]>(this.fs.readdir, path);
-    }
-    fopen(path: string, flags: string | number, mode: number) {
-        return this.promisify<FileDescriptor>(this.fs.open, path, flags, mode);
-    }
-    fread(fd: FileDescriptor, buf: Uint8Array, offset: number,
-        length: number, pos: number | null) {
-        return this.promisify<number>(this.fs.read, fd, toBuffer(buf),
-            offset, length, pos);
-    }
-    fwrite(fd: FileDescriptor, buf: Uint8Array, offset: number,
-        length: number, pos: number | null) {
-        return this.promisify<number>(this.fs.write, fd, toBuffer(buf),
-            offset, length, pos);
-    }
-    fstat(fd: FileDescriptor) {
-        return this.promisify<Stats>(this.fs.fstat, fd);
-    }
-    fclose(fd: FileDescriptor) {
-        return this.promisify<void>(this.fs.close, fd);
-    }
-
-    // helpers
-    async stat(path: string) {
-        const fd: number | null = await (this.fopen(path, "\\r", 0o666)
-            .catch((e: Error & { code: string }) => {
-                if (e.code === "NOENT") {
-                    return null;
-                }
-
-                throw e;
-            }));
-        if (fd === null) {
-            return null;
-        }
-        const stat = await this.fstat(fd);
-        await this.fclose(fd);
-        return stat;
-    }
-
-    async isdir(path: string) {
-        const stat = await this.stat(path);
-        return stat !== null ? stat.isDirectory() : false;
-    }
-
-    async exists(path: string) {
-        return (await this.stat(path)) !== null;
-    }
-}
-
-export interface StatsBase<T> {
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isSymbolicLink(): boolean;
-    isFIFO(): boolean;
-    isSocket(): boolean;
-    dev: T;
-    ino: T;
-    mode: T;
-    nlink: T;
-    uid: T;
-    gid: T;
-    rdev: T;
-    size: T;
-    blksize: T;
-    blocks: T;
-    atimeMs: T;
-    mtimeMs: T;
-    ctimeMs: T;
-    birthtimeMs: T;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-}
-
-export interface Stats extends StatsBase<number> { }
-
-export async function createSockdriveFileSystem(endpoint: string,
-                                                ownerId: string,
-                                                driveId: string,
-                                                token: string,
-                                                onOpen: (read: boolean, write: boolean) => void = () => { },
-                                                onError: (e: Error) => void = () => { }) {
-    const stats: SockdriveStats = {
-        read: 0,
-        write: 0,
-        readTotalTime: 0,
-        cacheHit: 0,
-        cacheMiss: 0,
-        cacheUsed: 0,
-    };
-
-    const sectorSize = 512;
-    const module: EmModule = {
-        HEAPU8: new Uint8Array(sectorSize),
-    };
-
-    let drive: Drive | null = null;
-    const fs = await new Promise<FileSystemApi>((resolve, reject) => {
-        drive = new Drive(endpoint, ownerId, driveId, token, stats, module);
-        drive.onOpen((read, write, imageSize) => {
-            // TODO: fatfs should respect boot record section
-            const MBR_OFFSET = 63;
-            const driver: Driver = {
-                sectorSize,
-                numSectors: imageSize / sectorSize,
-                readSectors: function(start, dst, cb) {
-                    (async () => {
-                        start += MBR_OFFSET;
-                        // TODO we can avoid copying in dst.set
-                        for (let i = 0; i < dst.length / sectorSize; ++i) {
-                            if (drive.read(start + i, 0, true) !== 0) {
-                                const readCode = await drive.read(start + i, 0, false);
-                                if (readCode !== 0) {
-                                    cb(new Error("Read error, code: " + readCode), dst);
-                                    return;
-                                }
-                            }
-                            dst.set(module.HEAPU8.slice(0, sectorSize), i * sectorSize);
-                        }
-                    })()
-                        .then(() => cb(null, dst))
-                        .catch((e) => cb(e, dst));
-                },
-                writeSectors: function(start, data, cb) {
-                    start += MBR_OFFSET;
-                    for (let i = 0; i < data.length / sectorSize; ++i) {
-                        module.HEAPU8.set(data.slice(i * sectorSize, (i + 1) * sectorSize), 0);
-                        const writeCode = drive.write(start + i, 0);
-                        if (writeCode !== 0) {
-                            cb(new Error("Write error, code: " + 0));
-                            return;
-                        }
-                    }
-                    cb(null);
-                },
-            };
-            const fs = (createFileSystem as any as CreateFileSystemApi)(driver, {}, (ev, reason) => {
-                if (ev === "ready") {
-                    resolve(fs);
-                } else {
-                    console.error(ev, reason);
-                    reject(reason);
-                }
-            });
-            onOpen(read, write);
-        });
-        drive.onError(onError);
-    });
-
-    return {
-        stats,
-        fs: new FileSystem(fs),
-        close: () => drive?.close(),
-    };
-}
-
-
-(window as any).createSockdriveFileSystem = createSockdriveFileSystem;
-(window as any).createFileSystem = createFileSystem;

package/src/sockdrive/js/src/sockdrive-native.ts

@@ -1,100 +0,0 @@
-import { EmModule, Handle, Ptr, Stats } from "./sockdrive/types";
-import { Drive } from "./sockdrive/drive";
-
-interface Template {
-    name: string,
-    size: number,
-    heads: number,
-    cylinders: number,
-    sectors: number,
-    sector_size: number,
-}
-
-declare const Module: EmModule & any;
-
-(function() {
-    let seq = 0;
-    const mapping: { [handle: Handle]: Drive } = {};
-    const templates: { [handle: number]: Template } = {};
-    const stats: Stats = {
-        read: 0,
-        write: 0,
-        readTotalTime: 0,
-        cacheHit: 0,
-        cacheMiss: 0,
-        cacheUsed: 0,
-    };
-    Module.sockdrive = {
-        stats,
-        onError: (e: Error) => {
-            console.error(e);
-        },
-        onOpen: (drive: string, read: boolean, write: boolean) => {
-            // noop
-        },
-        onPreloadProgress: (dirve: string, restBytes: number) => {
-            // noop
-        },
-        open: async (url: string, owner: string, name: string, token: string): Promise<Handle> => {
-            const response = await fetch(url.replace("wss://", "https://")
-                .replace("ws://", "http://") + "/template/" + owner + "/" + name);
-            const template = await response.json();
-            if (template.error) {
-                throw new Error(template.error);
-            }
-            seq++;
-            templates[seq] = template;
-            return new Promise<Handle>((resolve, reject) => {
-                mapping[seq] = new Drive(url, owner, name, token, stats, Module);
-                mapping[seq].onOpen((read, write, imageSize, preloadQueue) => {
-                    Module.sockdrive.onOpen(owner + "/" + name, read, write, imageSize, preloadQueue);
-                    resolve(seq);
-                });
-                mapping[seq].onError((e) => {
-                    Module.sockdrive.onError(e);
-                    reject(e);
-                });
-                mapping[seq].onPreloadProgress((restBytes) => {
-                    Module.sockdrive.onPreloadProgress(owner + "/" + name, restBytes);
-                });
-            });
-        },
-        read: (handle: Handle, sector: number, buffer: Ptr, sync: boolean): Promise<number> | number => {
-            if (mapping[handle]) {
-                return mapping[handle].read(sector, buffer, sync);
-            }
-
-            console.error("ERROR! sockdrive handle", handle, "not found");
-            return sync ? 1 : Promise.resolve(1);
-        },
-        write: (handle: Handle, sector: number, buffer: Ptr): number => {
-            if (mapping[handle]) {
-                return mapping[handle].write(sector, buffer);
-            }
-            console.error("ERROR! sockdrive handle", handle, "not found");
-            return 1;
-        },
-        close: (handle: Handle) => {
-            if (mapping[handle]) {
-                Module._free(mapping[handle].readAheadBuffer);
-                mapping[handle].close();
-                delete mapping[handle];
-            }
-        },
-        size: (handle: Handle) => {
-            return templates[handle]?.size ?? 0;
-        },
-        sector_size: (handle: Handle) => {
-            return templates[handle]?.sector_size ?? 512;
-        },
-        heads: (handle: Handle) => {
-            return templates[handle]?.heads ?? 1;
-        },
-        cylinders: (handle: Handle) => {
-            return templates[handle]?.cylinders ?? 520;
-        },
-        sectors: (handle: Handle) => {
-            return templates[handle]?.sectors ?? 63;
-        },
-    };
-})();

package/src/sockdrive/js/src/test/test.ts

@@ -1,289 +0,0 @@
-import { FileSystem, FileSystemApi, CreateFileSystemApi, Driver, CreateSockdriveFileSystem } from "../sockdrive-fat";
-import { Drive } from "../sockdrive/drive";
-import { EmModule, Stats } from "../sockdrive/types";
-
-declare const createFileSystem: CreateFileSystemApi;
-declare const createSockdriveFileSystem: CreateSockdriveFileSystem;
-
-const baseDir = "/test";
-const file = baseDir + "/Simple File.txt";
-
-async function runTests() {
-    const assert = chai.assert;
-    function createDriver(orig: Uint8Array): Driver {
-        const image = orig.slice(0, orig.length);
-        const sectorSize = 512;
-        return {
-            sectorSize,
-            numSectors: image.length / 512,
-            readSectors: function(sector, dst, cb) {
-                dst.set(image.slice(sector * sectorSize, sector * sectorSize + dst.length));
-                cb(null, dst);
-            },
-            writeSectors: function(sector, data, cb) {
-                image.set(data, sector * sectorSize);
-                cb(null);
-            },
-        };
-    }
-
-    const loadImage = async (url: string) => new Uint8Array(await (await fetch(url)).arrayBuffer());
-    const images: { [key: string]: Uint8Array } = {
-        fat12: await loadImage("test/fat12.img"),
-        fat16: await loadImage("test/fat16.img"),
-        fat32: await loadImage("test/fat32.img"),
-    };
-
-    const writeBuf = new Uint8Array(4096 * 4);
-    for (let i = 0; i < writeBuf.length; ++i) {
-        writeBuf[i] = i % 256;
-    }
-
-    const testRead = async (fs: FileSystem) => {
-        const readBuf = new Uint8Array(writeBuf.length);
-        const fd = await fs.fopen(file, "r", 0o666);
-        assert.equal((await fs.fstat(fd)).size, writeBuf.length);
-        assert.equal(await fs.fread(fd, readBuf, 0, readBuf.length, 0), readBuf.length);
-        assert.deepEqual(readBuf, writeBuf);
-        await fs.fclose(fd);
-    };
-
-    const testOpenWriteStatClose = async (fs: FileSystem) => {
-        try {
-            await fs.mkdir(baseDir);
-        } catch (e) {
-            // ignore if exists
-        }
-        const fd = await fs.fopen(file, "w", 0o666);
-        assert.ok(fd);
-        assert.equal(await fs.fwrite(fd, writeBuf, 0, writeBuf.length, null), writeBuf.length);
-        await fs.fclose(fd);
-        await testRead(fs);
-    };
-
-    const testHelpers = async (fs: FileSystem) => {
-        assert.isFalse(await fs.exists("/not-exists"), "/not-exists not exits");
-        assert.isTrue(await fs.exists(baseDir), "baseDir exists");
-        assert.isTrue(await fs.exists(file), "file exists");
-        assert.isTrue(await fs.isdir(baseDir), "baseDir is dir");
-        assert.isFalse(await fs.isdir(file), "file is file");
-    };
-
-    for (const name of Object.keys(images)) {
-        const driver = () => createDriver(images[name]);
-        const fs = () => new Promise<FileSystemApi>((resolve, reject) => {
-            const fs = createFileSystem(driver(), {}, (ev, reason) => {
-                if (ev === "ready") {
-                    resolve(fs);
-                } else {
-                    console.error(ev, reason);
-                    reject(reason);
-                }
-            });
-        });
-        suite(name + ".driver");
-
-        test("create driver", () => {
-            assert.exists(driver());
-        });
-
-        test("create fs", async () => {
-            assert.exists(await fs());
-        });
-
-        const testFs = (name: string, fn: (fs: FileSystem) => Promise<void>) => {
-            test(name, async () => fn(new FileSystem(await fs())));
-        };
-
-        testFs("api", async (fs) => {
-            for (const method of [
-                "mkdir", "readdir",
-                // "rename", "unlink", "rmdir",
-                "fclose", "fopen", "fwrite", "fread", "fstat",
-                "stat", "exists", "isdir",
-                // "fsync",
-                // "ftruncate", "truncate",
-                // "readFile", "writeFile", "appendFile",
-
-                // "chown", "lchown", "fchown",
-                // "chmod", "lchmod", "fchmod",
-                // "utimes", "futimes",
-                // "lstat", "fstat",
-                // "link", "symlink", "readlink", "realpath",
-
-                // 'watchfile','unwatchfile','watch'
-            ]) {
-                assert.ok(method in fs, "fs." + method + " has implementation.");
-            };
-        });
-
-        testFs("readdir", async (fs) => {
-            const files = await fs.readdir("/");
-            assert.ok(Array.isArray(files));
-            assert.ok(files.length === 0, "image is empty");
-        });
-
-        testFs("mkdir", async (fs) => {
-            await fs.mkdir(baseDir);
-            assert.ok((await fs.readdir(baseDir)).length === 0, "base dir is empty");
-            const root = await fs.readdir("/");
-            assert.ok(root.length === 1, "root have 1 folder");
-            assert.equal("/" + root[0], baseDir);
-        });
-
-        testFs("open/write/stat/read/close", testOpenWriteStatClose);
-
-        testFs("exists/isdir", async (fs) => {
-            await testOpenWriteStatClose(fs);
-            await testHelpers(fs);
-        });
-    }
-
-    suite("Drive 127.0.0.1:8001");
-
-    const testDrive = (name: string,
-        fn: (drive: Drive, module: EmModule, stats: Stats, preloadQueue: number[]) => Promise<void>,
-        preload = false) => {
-        test(name, async () => {
-            const module: EmModule = {
-                HEAPU8: new Uint8Array(512),
-            };
-
-            const stats: Stats = {
-                read: 0,
-                write: 0,
-                readTotalTime: 0,
-                cacheHit: 0,
-                cacheMiss: 0,
-                cacheUsed: 0,
-            };
-
-            const drive = new Drive("ws://127.0.0.1:8001", "system", "test", "", stats, module, preload);
-            let preloadQueue: number[] = [];
-            await new Promise<void>((resolve, reject) => {
-                drive.onOpen((read, write, imageSize, preload) => {
-                    if (!preload) {
-                        assert.equal(0, preload.length);
-                    }
-                    preloadQueue = [...preload];
-                    resolve();
-                });
-                drive.onError((e) => {
-                    reject(e);
-                });
-            });
-
-            await fn(drive, module, stats, preloadQueue);
-            await drive.close();
-        });
-    };
-
-    testDrive("read sector", async (drive, module, stats) => {
-        assert.equal(await drive.read(0, 0, false), 0);
-        assert.deepEqual(module.HEAPU8.slice(0, 10), new Uint8Array([51, 192, 142, 208, 188, 0, 124, 251, 80, 7]));
-        assert.equal(1, stats.cacheMiss, "cache miss");
-        assert.equal(0, stats.cacheHit, "cache hit");
-
-        assert.equal(await drive.read(8192, 0, false), 0);
-        assert.deepEqual(module.HEAPU8.slice(0, 10), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-        assert.equal(2, stats.cacheMiss, "cache miss");
-        assert.equal(0, stats.cacheHit, "cache hit");
-
-        assert.equal(await drive.read(8448, 0, false), 0);
-        assert.deepEqual(module.HEAPU8.slice(256, 256 + 10), new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        assert.equal(2, stats.cacheMiss, "cache miss");
-        assert.equal(1, stats.cacheHit, "cache hit");
-    });
-
-    testDrive("read cache", async (drive, module, stats) => {
-        assert.equal(await drive.read(0, 0, false), 0);
-        assert.equal(0, stats.cacheHit, "cache hit");
-        assert.equal(1, stats.cacheMiss, "cache miss");
-
-        for (let i = 0; i < 128; ++i) {
-            assert.equal(await drive.read(1 + i, 0, true), 0);
-            assert.equal(i + 1, stats.cacheHit, "cache hit");
-            assert.equal(1, stats.cacheMiss, "cache miss");
-            if (i == 62) {
-                assert.deepEqual(module.HEAPU8.slice(0, 10),
-                    new Uint8Array([235, 88, 144, 77, 83, 87, 73, 78, 52, 46]));
-            }
-            if (i == 127) {
-                assert.deepEqual(module.HEAPU8.slice(0, 10),
-                    new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-            }
-        }
-    });
-
-    testDrive("preload sectors", async (drive, module, stats, preloadQueue) => {
-        assert.ok(preloadQueue.length >= 2);
-        let _0 = false;
-        let _8192 = false;
-        for (const next of preloadQueue) {
-            _0 = _0 || next === 0;
-            _8192 = _8192 || next === 8192;
-        }
-        assert.ok(_0 && _8192);
-
-        await new Promise<void>((resolve) => setTimeout(resolve, 1000));
-
-        assert.equal(drive.read(0, 0, true), 0, "sector 0 in cache");
-        assert.deepEqual(module.HEAPU8.slice(0, 10), new Uint8Array([51, 192, 142, 208, 188, 0, 124, 251, 80, 7]));
-
-        assert.equal(await drive.read(8192, 0, true), 0, "sector 8192 in cache");
-        assert.deepEqual(module.HEAPU8.slice(0, 10), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-
-        assert.equal(await drive.read(8448, 0, true), 0, "sector 8448 in cache");
-        assert.deepEqual(module.HEAPU8.slice(256, 256 + 10), new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
-
-        assert.equal(3, stats.cacheHit, "cache hit");
-        assert.equal(0, stats.cacheMiss, "cache miss");
-    }, true);
-
-    suite("sockdrive 127.0.0.1:8001");
-
-    test("error on wrong drive name", (done) => {
-        createSockdriveFileSystem("ws://127.0.0.1:8001", "system", "not-exists", "",
-            () => { },
-            (e) => {
-                assert.strictEqual(e.message, "Err: no such drive");
-                done();
-            });
-    });
-
-    const testSd = (name: string, fn: (fs: FileSystem) => Promise<void>, writeCheck?: number[]) => {
-        test(name, async () => {
-            const { stats, fs, close } = await createSockdriveFileSystem("ws://127.0.0.1:8001", "system", "test", "",
-                (read, write) => {
-                    assert.isTrue(read, "read access");
-                    assert.isTrue(write, "write access");
-                });
-            await fn(fs);
-            await new Promise<void>((resolve) => {
-                setTimeout(resolve, 16);
-            });
-            await close();
-            if (writeCheck) {
-                assert.isTrue(writeCheck.findIndex((v) => v === stats.write) >= 0,
-                    "write check " + stats.write + " in " + writeCheck);
-            }
-        });
-    };
-
-    testSd("connect", async (fs) => {
-        assert.ok(fs);
-    });
-
-    testSd("readdir /", async (fs) => {
-        assert.ok(await fs.readdir("/"));
-    });
-
-    testSd("open/write/stat/read/close", testOpenWriteStatClose);
-    testSd("reconnect stat/read/close", testRead);
-    testSd("exists/isdir", testHelpers);
-
-
-    mocha.run();
-}
-
-(window as any).runTests = runTests;

package/src/sockdrive/js/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist/",
-    "noImplicitAny": true,
-    "module": "es6",
-    "target": "es6",
-    "jsx": "react",
-    "allowJs": true,
-    "moduleResolution": "node"
-  }
-}