@rcompat/test 0.0.2 → 0.1.1

package/lib/private/Assert.d.ts

@@ -0,0 +1,16 @@
+import type Test from "#Test";
+import type UnknownFunction from "@rcompat/type/UnknownFunction";
+export default class Assert<T> {
+    #private;
+    constructor(actual: T, test: Test);
+    equals<Expected extends T>(expected?: Expected): void;
+    nequals(expected: unknown): void;
+    true(): void;
+    false(): void;
+    null(): void;
+    undefined(): void;
+    instance(expected: UnknownFunction): void;
+    throws(expected?: string): void;
+    tries(): void;
+}
+//# sourceMappingURL=Assert.d.ts.map

package/lib/private/Assert.js

@@ -0,0 +1,62 @@
+import E from "#E";
+import equals from "#equals";
+export default class Assert {
+    #actual;
+    #test;
+    constructor(actual, test) {
+        this.#actual = actual;
+        this.#test = test;
+    }
+    #report(expected, passed) {
+        this.#test.report(this.#actual, expected, passed);
+    }
+    equals(expected) {
+        if (expected !== undefined) {
+            this.#report(expected, equals(this.#actual, expected));
+        }
+    }
+    nequals(expected) {
+        this.#report(expected, !equals(this.#actual, expected));
+    }
+    #static(expected) {
+        this.#report(expected, equals(this.#actual, expected));
+    }
+    true() {
+        this.#static(true);
+    }
+    false() {
+        this.#static(false);
+    }
+    null() {
+        this.#static(null);
+    }
+    undefined() {
+        this.#static(undefined);
+    }
+    instance(expected) {
+        this.#report(expected, this.#actual instanceof expected);
+    }
+    throws(expected) {
+        try {
+            this.#actual();
+            this.#report("[void]", false);
+        }
+        catch (error) {
+            const { message } = E(error);
+            const messaged = expected !== undefined;
+            this.#report(message, messaged ? equals(message, expected) : true);
+        }
+    }
+    tries() {
+        try {
+            this.#actual();
+            this.#report("[void]", true);
+        }
+        catch (error) {
+            const { message } = E(error);
+            this.#report(`[threw] ${message}`, false);
+        }
+    }
+}
+;
+//# sourceMappingURL=Assert.js.map

package/lib/private/Asserter.d.ts

@@ -0,0 +1,4 @@
+import Assert from "#Assert";
+type Asserter = <T>(actual: T) => Assert<T>;
+export { Asserter as default };
+//# sourceMappingURL=Asserter.d.ts.map

package/lib/private/Asserter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Asserter.js.map

package/lib/private/Body.d.ts

@@ -0,0 +1,4 @@
+import Asserter from "#Asserter";
+type Body = (asserter: Asserter) => void;
+export { Body as default };
+//# sourceMappingURL=Body.d.ts.map

package/lib/private/Body.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Body.js.map

package/lib/private/E.d.ts

@@ -0,0 +1,6 @@
+type ErrorMessage = {
+    message: string;
+};
+declare const _default: (error: unknown) => ErrorMessage;
+export default _default;
+//# sourceMappingURL=E.d.ts.map

package/lib/private/E.js

@@ -0,0 +1,2 @@
+export default (error) => error;
+//# sourceMappingURL=E.js.map

package/lib/private/NEVER.d.ts

@@ -0,0 +1,6 @@
+declare const NEVER: {
+    (value: unknown): never;
+    undefined: never;
+};
+export default NEVER;
+//# sourceMappingURL=NEVER.d.ts.map

package/lib/private/NEVER.js

@@ -0,0 +1,4 @@
+const NEVER = (value) => value;
+NEVER.undefined = NEVER(undefined);
+export default NEVER;
+//# sourceMappingURL=NEVER.js.map

package/lib/private/Result.d.ts

@@ -0,0 +1,8 @@
+export default class Result<T> {
+    #private;
+    constructor(actual: T, expected: T, passed: boolean);
+    get actual(): T;
+    get expected(): T;
+    get passed(): boolean;
+}
+//# sourceMappingURL=Result.d.ts.map

package/lib/private/Result.js

@@ -0,0 +1,21 @@
+export default class Result {
+    #actual;
+    #expected;
+    #passed;
+    constructor(actual, expected, passed) {
+        this.#actual = actual;
+        this.#expected = expected;
+        this.#passed = passed;
+    }
+    get actual() {
+        return this.#actual;
+    }
+    get expected() {
+        return this.#expected;
+    }
+    get passed() {
+        return this.#passed;
+    }
+}
+;
+//# sourceMappingURL=Result.js.map

package/lib/private/Test.d.ts

@@ -0,0 +1,13 @@
+import Body from "#Body";
+import Result from "#Result";
+import type FileRef from "@rcompat/fs/FileRef";
+export default class Test {
+    #private;
+    constructor(name: string, body: Body, file: FileRef);
+    get name(): string;
+    get file(): FileRef;
+    get results(): Result<unknown>[];
+    report<T>(actual: T, expected: T, passed: boolean): void;
+    run(): void;
+}
+//# sourceMappingURL=Test.d.ts.map

package/lib/private/Test.js

@@ -0,0 +1,30 @@
+import Assert from "#Assert";
+import Result from "#Result";
+export default class Test {
+    #name;
+    #body;
+    #results = [];
+    #file;
+    constructor(name, body, file) {
+        this.#name = name;
+        this.#body = body;
+        this.#file = file;
+    }
+    get name() {
+        return this.#name;
+    }
+    get file() {
+        return this.#file;
+    }
+    get results() {
+        return this.#results;
+    }
+    report(actual, expected, passed) {
+        this.#results.push(new Result(actual, expected, passed));
+    }
+    run() {
+        this.#body((actual) => new Assert(actual, this));
+    }
+}
+;
+//# sourceMappingURL=Test.js.map

package/lib/private/equals.js

@@ -1,5 +1,6 @@
 import array from "#types/array";
 import date from "#types/date";
+import fn from "#types/fn";
 import map from "#types/map";
 import nul from "#types/null";
 import record from "#types/record";
@@ -12,7 +13,9 @@ const checks = [
     [array.is, (x, y) => array.is(y) && array.equal(x, y)],
     [set.is, (x, y) => set.is(y) && set.equal(x, y)],
     [map.is, (x, y) => map.is(y) && map.equal(x, y)],
-    [record.is, (x, y) => record.is(y) && record.equal(x, y)],
+    [fn.is, (x, y) => fn.is(y) && fn.equal(x, y)],
+    [record.is, (x, y) => record.is(y)
+            && record.equal(x, y)],
     [(_) => true, (_, _1) => false]
 ];
 const equals = (x, y) => typeof x === typeof y

package/lib/private/index.d.ts

@@ -0,0 +1,6 @@
+import Body from "#Body";
+declare const _default: {
+    case(name: string, body: Body): void;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -0,0 +1,7 @@
+import repository from "#repository";
+export default {
+    case(name, body) {
+        repository.put(name, body);
+    }
+};
+//# sourceMappingURL=index.js.map

package/lib/private/repository.d.ts

@@ -0,0 +1,13 @@
+import type Body from "#Body";
+import Test from "#Test";
+import type FileRef from "@rcompat/fs/FileRef";
+declare class Repository {
+    #private;
+    reset(): void;
+    put(name: string, body: Body): void;
+    current(file: FileRef): void;
+    run(): Generator<Test, void, unknown>;
+}
+declare const _default: Repository;
+export default _default;
+//# sourceMappingURL=repository.d.ts.map

package/lib/private/repository.js

@@ -0,0 +1,22 @@
+import Test from "#Test";
+class Repository {
+    #tests = [];
+    #current;
+    reset() {
+        this.#tests = [];
+    }
+    put(name, body) {
+        this.#tests.push(new Test(name, body, this.#current));
+    }
+    current(file) {
+        this.#current = file;
+    }
+    *run() {
+        for (const test of this.#tests) {
+            test.run();
+            yield test;
+        }
+    }
+}
+export default new Repository();
+//# sourceMappingURL=repository.js.map

package/lib/private/to-object.d.ts

@@ -1,4 +1,4 @@
-import type { UnknownMap } from "#types/map";
+import type UnknownMap from "@rcompat/type/UnknownMap";
 declare const _default: (map: UnknownMap) => {
     [k: string]: unknown;
 };

package/lib/private/types/fn.d.ts

@@ -0,0 +1,7 @@
+import type UnknownFunction from "@rcompat/type/UnknownFunction";
+declare const _default: {
+    is: (x: unknown) => x is UnknownFunction;
+    equal: <T extends UnknownFunction>(x: T, y: T) => boolean;
+};
+export default _default;
+//# sourceMappingURL=fn.d.ts.map

package/lib/private/types/fn.js

@@ -0,0 +1,4 @@
+const is = (x) => typeof x === "function";
+const equal = (x, y) => x.length === y.length;
+export default { is, equal };
+//# sourceMappingURL=fn.js.map

package/lib/private/types/map.d.ts

@@ -1,4 +1,4 @@
-export type UnknownMap = Map<PropertyKey, unknown>;
+import type UnknownMap from "@rcompat/type/UnknownMap";
 declare const _default: {
     equal: <T extends UnknownMap>(x: T, y: T) => boolean;
     include: <T extends UnknownMap>(x: T, y: T) => boolean;

package/lib/private/types/record.d.ts

@@ -1,4 +1,4 @@
-import Dictionary from "@rcompat/record/Dictionary";
+import type Dictionary from "@rcompat/type/Dictionary";
 declare const _default: {
     equal: <T extends Dictionary>(x: T, y: T) => boolean;
     include: <T extends Dictionary>(x: T, y: T) => boolean;

package/lib/private/types/set.d.ts

@@ -1,4 +1,4 @@
-export type UnknownSet = Set<unknown>;
+import type UnknownSet from "@rcompat/type/UnknownSet";
 declare const _default: {
     equal: <T extends UnknownSet>(x: T, y: T) => boolean;
     include: <T extends UnknownSet>(x: T, y: T) => boolean;

package/lib/public/Asserter.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#Asserter";
+//# sourceMappingURL=Asserter.d.ts.map

package/lib/public/Asserter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Asserter.js.map

package/lib/public/E.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#E";
+//# sourceMappingURL=E.d.ts.map

package/lib/public/E.js

@@ -0,0 +1,2 @@
+export { default } from "#E";
+//# sourceMappingURL=E.js.map

package/lib/public/NEVER.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#NEVER";
+//# sourceMappingURL=NEVER.d.ts.map

package/lib/public/NEVER.js

@@ -0,0 +1,2 @@
+export { default } from "#NEVER";
+//# sourceMappingURL=NEVER.js.map

package/lib/public/Result.d.ts

@@ -0,0 +1,3 @@
+import type Result from "#Result";
+export type { Result as default };
+//# sourceMappingURL=Result.d.ts.map

package/lib/public/Result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Result.js.map

package/lib/public/Test.d.ts

@@ -0,0 +1,3 @@
+import type Test from "#Test";
+export type { Test as default };
+//# sourceMappingURL=Test.d.ts.map

package/lib/public/Test.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Test.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#index";
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,2 @@
+export { default } from "#index";
+//# sourceMappingURL=index.js.map

package/lib/public/repository.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#repository";
+//# sourceMappingURL=repository.d.ts.map

package/lib/public/repository.js

@@ -0,0 +1,2 @@
+export { default } from "#repository";
+//# sourceMappingURL=repository.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcompat/test",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "test module",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",
@@ -14,30 +14,43 @@
     "url": "https://github.com/rcompat/rcompat",
     "directory": "packages/test"
   },
+  "devDependencies": {
+    "@rcompat/fs": "^0.12.2"
+  },
   "dependencies": {
-    "@rcompat/core": "^0.6.0",
-    "@rcompat/record": "^0.6.2"
+    "@rcompat/record": "^0.7.0"
   },
   "type": "module",
   "imports": {
+    "#mask/*": {
+      "apekit": "./src/private/mask/*.ts",
+      "default": "./lib/private/mask/*.js"
+    },
     "#types/*": {
-      "livetypes": "./src/private/types/*.ts",
+      "apekit": "./src/private/types/*.ts",
       "default": "./lib/private/types/*.js"
     },
     "#*": {
-      "livetypes": "./src/private/*.ts",
+      "apekit": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
+    "./mask/*": {
+      "apekit": "./src/public/mask/*.ts",
+      "default": "./lib/public/mask/*.js"
+    },
     "./*": {
-      "livetypes": "./src/public/*.ts",
+      "apekit": "./src/public/*.ts",
       "default": "./lib/public/*.js"
+    },
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
     }
   },
   "scripts": {
     "build": "npm run clean && tsc",
-    "clean": "rm -rf ./lib",
-    "test": "tsx --conditions=livetypes ../../node_modules/debris/src/bin.js"
+    "clean": "rm -rf ./lib"
   }
 }

package/lib/private/detype.d.ts

@@ -1,3 +0,0 @@
-declare const _default: <T>(t: (...params: any[]) => T) => (...params: any[]) => T;
-export default _default;
-//# sourceMappingURL=detype.d.ts.map

package/lib/private/detype.js

@@ -1,2 +0,0 @@
-export default (t) => t;
-//# sourceMappingURL=detype.js.map

package/lib/public/detype.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#detype";
-//# sourceMappingURL=detype.d.ts.map

package/lib/public/detype.js

@@ -1,2 +0,0 @@
-export { default } from "#detype";
-//# sourceMappingURL=detype.js.map