@rcompat/test 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/private/equals.d.ts

@@ -0,0 +1,3 @@
+declare const equals: <T>(x: T, y: T) => boolean;
+export { equals as default };
+//# sourceMappingURL=equals.d.ts.map

package/lib/private/equals.js

@@ -0,0 +1,22 @@
+import array from "#types/array";
+import date from "#types/date";
+import map from "#types/map";
+import nul from "#types/null";
+import record from "#types/record";
+import scalar from "#types/scalar";
+import set from "#types/set";
+const checks = [
+    [scalar.is, (x, y) => scalar.is(y) && scalar.equal(x, y)],
+    [nul.is, (_, y) => nul.is(y)],
+    [date.is, (x, y) => date.is(y) && date.equal(x, y)],
+    [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)],
+    [(_) => true, (_, _1) => false]
+];
+const equals = (x, y) => typeof x === typeof y
+    ? checks.find(([predicate]) => predicate(x))[1](x, y)
+    : false;
+export { equals as default };
+//# sourceMappingURL=equals.js.map

package/lib/private/includes.d.ts

@@ -0,0 +1,3 @@
+declare const includes: <T>(x: T, y: T) => boolean;
+export { includes as default };
+//# sourceMappingURL=includes.d.ts.map

package/lib/private/includes.js

@@ -0,0 +1,22 @@
+import equals from "#equals";
+import array from "#types/array";
+import date from "#types/date";
+import map from "#types/map";
+import record from "#types/record";
+import set from "#types/set";
+import string from "#types/string";
+const includes = (x, y) => typeof x === typeof y
+    ? equals(x, y)
+        ? true
+        : [
+            [string.is, (x, y) => string.is(y) && string.include(x, y)],
+            [date.is, (x, y) => date.is(y) && date.include(x, y)],
+            [array.is, (x, y) => array.is(y) && array.include(x, y)],
+            [set.is, (x, y) => set.is(y) && set.include(x, y)],
+            [map.is, (x, y) => map.is(y) && map.include(x, y)],
+            [record.is, (x, y) => record.is(y) && record.include(x, y)],
+            [() => true, () => false],
+        ].find(([predicate]) => predicate(x))[1](x, y)
+    : false;
+export { includes as default };
+//# sourceMappingURL=includes.js.map

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

@@ -0,0 +1,6 @@
+import type { UnknownMap } from "#types/map";
+declare const _default: (map: UnknownMap) => {
+    [k: string]: unknown;
+};
+export default _default;
+//# sourceMappingURL=to-object.d.ts.map

package/lib/private/to-object.js

@@ -0,0 +1,2 @@
+export default (map) => Object.fromEntries(map.entries());
+//# sourceMappingURL=to-object.js.map

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    equal: <T extends unknown[]>(x: T, y: T) => boolean;
+    include: <T extends unknown[]>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is unknown[];
+    partial: <t extends unknown[]>(x: t, y: t) => boolean;
+};
+export default _default;
+//# sourceMappingURL=array.d.ts.map

package/lib/private/types/array.js

@@ -0,0 +1,28 @@
+import equals from "#equals";
+import includes from "#includes";
+const is = (x) => Array.isArray(x);
+const partial = (x, y) => x.reduce((equal, xi, i) => equal && equals(xi, y[i]), true);
+const equal = (x, y) => partial(x, y) && partial(y, x);
+const include = (x, y) => {
+    // empty array is always included
+    if (y.length === 0) {
+        return true;
+    }
+    if (x.length < y.length) {
+        return false;
+    }
+    // find index of first member
+    const index = x.findIndex(m => includes(m, y[0]));
+    // not found
+    if (index === -1) {
+        return false;
+    }
+    // assert subarray size can match
+    if (x.slice(index).length < y.length) {
+        return false;
+    }
+    // compare rest of members from y[1]]
+    return y.slice(1).reduce((included, member, i) => included && includes(x[index + i + 1], member), true);
+};
+export default { equal, include, is, partial };
+//# sourceMappingURL=array.js.map

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    equal: <T extends Date>(x: T, y: T) => boolean;
+    include: <T extends Date>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is Date;
+    partial: <T extends Date>(x: T, y: T) => boolean;
+};
+export default _default;
+//# sourceMappingURL=date.d.ts.map

package/lib/private/types/date.js

@@ -0,0 +1,6 @@
+const is = (x) => x instanceof Date;
+const equal = (x, y) => x.getTime() === y.getTime();
+const partial = equal;
+const include = equal;
+export default { equal, include, is, partial };
+//# sourceMappingURL=date.js.map

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

@@ -0,0 +1,9 @@
+export type UnknownMap = Map<PropertyKey, unknown>;
+declare const _default: {
+    equal: <T extends UnknownMap>(x: T, y: T) => boolean;
+    include: <T extends UnknownMap>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is UnknownMap;
+    partial: <T extends UnknownMap>(x: T, y: T) => boolean;
+};
+export default _default;
+//# sourceMappingURL=map.d.ts.map

package/lib/private/types/map.js

@@ -0,0 +1,8 @@
+import to_object from "#to-object";
+import record from "#types/record";
+const is = (x) => x instanceof Map;
+const include = (x, y) => record.include(to_object(x), to_object(y));
+const equal = (x, y) => record.equal(to_object(x), to_object(y));
+const partial = equal;
+export default { equal, include, is, partial };
+//# sourceMappingURL=map.js.map

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    is: (x: unknown) => x is null;
+};
+export default _default;
+//# sourceMappingURL=null.d.ts.map

package/lib/private/types/null.js

@@ -0,0 +1,3 @@
+const is = (x) => x === null;
+export default { is };
+//# sourceMappingURL=null.js.map

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

@@ -0,0 +1,9 @@
+import Dictionary from "@rcompat/record/Dictionary";
+declare const _default: {
+    equal: <T extends Dictionary>(x: T, y: T) => boolean;
+    include: <T extends Dictionary>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is Dictionary;
+    partial: <t extends Dictionary>(x: t, y: t) => boolean;
+};
+export default _default;
+//# sourceMappingURL=record.d.ts.map

package/lib/private/types/record.js

@@ -0,0 +1,10 @@
+import equals from "#equals";
+import includes from "#includes";
+const is_null = (x) => x === null;
+const is = (x) => typeof x === "object" && !is_null(x);
+const partial = (x, y) => Object.keys(x).reduce((equal, key) => equal && equals(x[key], y[key]), true);
+const equal = (x, y) => Object.keys(x).length === Object.keys(y).length && partial(x, y);
+const include = (x, y) => Object.keys(x).length >= Object.keys(y).length &&
+    Object.keys(y).reduce((included, key) => included && includes(x[key], y[key]), true);
+export default { equal, include, is, partial };
+//# sourceMappingURL=record.js.map

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

@@ -0,0 +1,10 @@
+declare const scalars: string[];
+type Scalar = typeof scalars[number];
+declare const _default: {
+    equal: <T>(x: T, y: T) => boolean;
+    include: <T>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is Scalar;
+    partial: <T>(x: T, y: T) => boolean;
+};
+export default _default;
+//# sourceMappingURL=scalar.d.ts.map

package/lib/private/types/scalar.js

@@ -0,0 +1,7 @@
+const scalars = ["bigint", "boolean", "number", "string", "symbol", "undefined"];
+const is = (x) => scalars.includes(typeof x);
+const equal = (x, y) => x === y || Object.is(x, y);
+const include = equal;
+const partial = equal;
+export default { equal, include, is, partial };
+//# sourceMappingURL=scalar.js.map

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

@@ -0,0 +1,9 @@
+export type UnknownSet = Set<unknown>;
+declare const _default: {
+    equal: <T extends UnknownSet>(x: T, y: T) => boolean;
+    include: <T extends UnknownSet>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is UnknownSet;
+    partial: <t extends unknown[]>(x: t, y: t) => boolean;
+};
+export default _default;
+//# sourceMappingURL=set.d.ts.map

package/lib/private/types/set.js

@@ -0,0 +1,12 @@
+import equals from "#equals";
+import includes from "#includes";
+const is = (x) => x instanceof Set;
+const partial = (x, y) => x.reduce((equal, xi) => equal && y.find(yj => equals(yj, xi)) !== undefined, true);
+const equal = (x, y) => x.isSubsetOf(y) && y.isSubsetOf(x)
+    || x.size === y.size
+        && partial([...x], [...y])
+        && partial([...y], [...x]);
+const deep_compare = (x, y) => y.reduce((included, yi) => included && x.find(xj => includes(xj, yi)) !== undefined, true);
+const include = (x, y) => y.isSubsetOf(x) || x.size >= y.size && deep_compare([...x], [...y]);
+export default { equal, include, is, partial };
+//# sourceMappingURL=set.js.map

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    equal: <T extends string>(x: T, y: T) => boolean;
+    include: <T extends string>(x: T, y: T) => boolean;
+    is: (x: unknown) => x is string;
+    partial: <T extends string>(x: T, y: T) => boolean;
+};
+export default _default;
+//# sourceMappingURL=string.d.ts.map

package/lib/private/types/string.js

@@ -0,0 +1,6 @@
+const is = (x) => typeof x === "string";
+const include = (x, y) => x.includes(y);
+const equal = (x, y) => x === y;
+const partial = equal;
+export default { equal, include, is, partial };
+//# sourceMappingURL=string.js.map

package/lib/public/equals.d.ts

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

package/lib/public/equals.js

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

package/lib/public/includes.d.ts

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

package/lib/public/includes.js

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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rcompat/test",
+  "version": "0.0.1",
+  "description": "test module",
+  "bugs": "https://github.com/rcompat/rcompat/issues",
+  "license": "MIT",
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rcompat/rcompat",
+    "directory": "packages/test"
+  },
+  "dependencies": {
+    "@rcompat/record": "^0.6.1",
+    "@rcompat/core": "^0.6.0"
+  },
+  "type": "module",
+  "imports": {
+    "#types/*": {
+      "livetypes": "./src/private/types/*.ts",
+      "default": "./lib/private/types/*.js"
+    },
+    "#*": {
+      "livetypes": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
+    }
+  },
+  "exports": {
+    "./*": {
+      "livetypes": "./src/public/*.ts",
+      "default": "./lib/public/*.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "test": "tsx --conditions=livetypes ../../node_modules/debris/src/bin.js"
+  }
+}