Initial commit

src/index.ts

@@ -0,0 +1,2 @@
+export { myFunction } from "./myFunction";
+export { myObject } from "./myObject";

src/myFunction.ts

@@ -0,0 +1,3 @@
+export function myFunction() {
+    return Promise.resolve(["a", "b", "c"]);
+}

src/myObject.ts

@@ -0,0 +1,3 @@
+import { toUpperCase } from "./tools/toUpperCase";
+
+export const myObject = { "p": toUpperCase("foo") };

src/test/getProjectRoot.ts

@@ -0,0 +1,5 @@
+import { getProjectRoot } from "../tools/getProjectRoot";
+
+console.log(
+    `Project root path: ${getProjectRoot()} does it seems right ? If yes then PASS`,
+);

src/test/index.ts

@@ -0,0 +1,41 @@
+//This will not run on deno, we need a separate test runner for Deno (./mod.ts).
+
+import * as child_process from "child_process";
+import * as path from "path";
+import { Deferred } from "evt/tools/Deferred";
+
+const names = ["myFunction", "myObject", "getProjectRoot"];
+
+(async () => {
+    if (!!process.env.FORK) {
+        process.once("unhandledRejection", error => {
+            throw error;
+        });
+
+        require(process.env.FORK);
+
+        return;
+    }
+
+    for (const name of names) {
+        console.log(`Running: ${name}`);
+
+        const dExitCode = new Deferred<number>();
+
+        child_process
+            .fork(__filename, undefined, {
+                "env": { "FORK": path.join(__dirname, name) },
+            })
+            .on("message", console.log)
+            .once("exit", code => dExitCode.resolve(code ?? 1));
+
+        const exitCode = await dExitCode.pr;
+
+        if (exitCode !== 0) {
+            console.log(`${name} exited with error code: ${exitCode}`);
+            process.exit(exitCode);
+        }
+
+        console.log("\n");
+    }
+})();

src/test/myFunction.ts

@@ -0,0 +1,16 @@
+import { myFunction } from "..";
+import { getPromiseAssertionApi } from "evt/tools/testing";
+
+const { mustResolve } = getPromiseAssertionApi({
+    "takeIntoAccountArraysOrdering": true,
+});
+
+(async () => {
+    await mustResolve({
+        "promise": myFunction(),
+        "expectedData": ["a", "b", "c"],
+        "delay": 0,
+    });
+
+    console.log("PASS");
+})();

src/test/myObject.ts

@@ -0,0 +1,7 @@
+import { assert } from "evt/tools/typeSafety";
+import * as inDepth from "evt/tools/inDepth";
+import { myObject } from "..";
+
+assert(inDepth.same(myObject, { "p": "FOO" }));
+
+console.log("PASS");

src/tools/getProjectRoot.ts

@@ -0,0 +1,19 @@
+import * as fs from "fs";
+import * as path from "path";
+
+function getProjectRootRec(dirPath: string): string {
+    if (fs.existsSync(path.join(dirPath, "package.json"))) {
+        return dirPath;
+    }
+    return getProjectRootRec(path.join(dirPath, ".."));
+}
+
+let result: string | undefined = undefined;
+
+export function getProjectRoot(): string {
+    if (result !== undefined) {
+        return result;
+    }
+
+    return (result = getProjectRootRec(__dirname));
+}

src/tools/toUpperCase.ts

@@ -0,0 +1,3 @@
+export function toUpperCase(str: string): string {
+    return str.toUpperCase();
+}