Initial commit

Author: Floofies

README.md

@@ -1,2 +1,89 @@
-# da-testdiff
-The "testDiff" deep diff/test function from Differentia.js, ported to TypeScript. Returns true if input 1 differs in any way from input 2. Performs deep object search by default, works OK with circular references.
+# js-testDiff
+
+- [About]("#about")
+- [Building]("#building")
+- [Syntax]("#syntax")
+- [Usage Examples]("#usage-examples")
+
+## About
+
+Deep object diffing function for JavaScript; returns true if input 1 differs in any way from input 2. Original code was taken from Differentia.js and ported to TypeScript.
+
+The testDiff function was originally created as a unit testing utility and it was primarily designed/used to test Differentia's search algorithm strategy system, setting a "gold standard" for that library's quality and algorithmic correctness.
+
+The key difference with this version of testDiff is that I removed its "search index" functionality, as it introduced more complexity than it was worth.
+
+Feel free to scavenge the original code as I have: https://github.com/Floofies/Differentia.js/blob/master/spec/testUtils.js
+
+## Building
+
+Run `npm run build` to compile and test module `dist/index.js`.
+
+I have pre-compiled the most up-to-date files in `dist`. Enjoy.
+
+`unitTest.js` can be safely ignored, as it's a development-only dependency for `test.mjs`.
+
+## Syntax
+
+```JavaScript
+import { testDiff } from "testDiff";
+```
+```JavaScript
+testDiff( input1:any, input2:any, [ deep:boolean = false ] );
+```
+
+### Parameters:
+
+#### `input1`, `input2`
+
+Two values/objects to compare against each other.
+
+#### `deep` (_Optional_) (_Default = `true`_)
+
+TestDiff performs "deep" object/array traversal by default, comparing all reachable values; set this operand to `false` to disable traversal and nested comparisons.
+
+### Return Value:
+
+Returns `true` if `input1`'s structure, properties, or values differ in any way from `input2`, or `false` if otherwsie.
+
+## Usage Examples
+
+### Example 1: Arbitrary values.
+
+Can handle any arbitrary values, as well as objects/arrays.
+
+```JavaScript
+const myArray1 = "Hello World!";
+const myArray2 = "This is a test";
+const result = testDiff(myArray1, myArray2);
+// result = true
+```
+
+### Example 2: Flat arrays/objects.
+
+```JavaScript
+const myArray1 = [1,2,3];
+const myArray2 = [4,5,6];
+const result = testDiff(myArray1, myArray2);
+// result = true
+```
+
+### Example 3: Nested arrays/objects.
+
+```JavaScript
+const myArray1 = ["Hello",["World!"]];
+const myArray2 = ["Hello",["Developer!"]];
+const result = testDiff(myArray1, myArray2);
+// result = true
+```
+
+### Example 4: Nested arrays. Traversal disabled.
+
+In this example, the function returns `false` even though the arrays' contents differ; they are regarded as the same because there are no differences at the top, and disabling traversal prevents the algorithm from seeing deeper differences.
+
+```JavaScript
+const myArray1 = ["Hello",["World!"]];
+const myArray2 = ["Hello",["Developer!"]];
+const result = testDiff(myArray1, myArray2, false);
+// result = false
+```

dist/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDiff = void 0;
+function testValue(value1, value2) {
+    if ((typeof value1) !== (typeof value2))
+        return true;
+    if (Number.isNaN(value1) !== Number.isNaN(value2))
+        return true;
+    if ((value1 !== value2))
+        return true;
+}
+// Returns true if obj1 differs in any way from obj2.
+function testDiff(obj1, obj2, deep) {
+    if (deep === void 0) { deep = true; }
+    if (obj1 === null)
+        return obj1 !== obj2;
+    // Cheap comparisons first
+    if (((typeof obj1) !== "object") && testValue(obj1, obj2))
+        return true;
+    var stack = [{ obj1: obj1, obj2: obj2 }];
+    var seen = new Map();
+    seen.set(obj1, stack[0]);
+    var _loop_1 = function () {
+        var objects = stack.pop();
+        if (Array.isArray(objects.obj1) !== Array.isArray(objects.obj2))
+            return { value: true };
+        var props1 = Object.keys(objects.obj1);
+        var props2 = Object.keys(objects.obj2);
+        if (props1.length === 0 && props2.length === 0)
+            return "continue";
+        if (props1.length !== props2.length)
+            return { value: true };
+        if (!props1.every(function (value) { return props2.includes(value); }))
+            return { value: true };
+        if (!props2.every(function (value) { return props1.includes(value); }))
+            return { value: true };
+        _props: for (var loc = 0; loc < props1.length; loc++) {
+            var prop = props1[loc];
+            var value1 = objects.obj1[prop];
+            var value2 = objects.obj2[prop];
+            if ((typeof value1) !== (typeof value2))
+                return { value: true };
+            if (value1 === null || (typeof value1) !== "object") {
+                if (testValue(value1, value2))
+                    return { value: true };
+                continue _props;
+            }
+            if (value1 instanceof RegExp && value2 instanceof RegExp) {
+                if (value1.source !== value2.source
+                    || value1.ignoreCase !== value2.ignoreCase
+                    || value1.global !== value2.global
+                    || value1.multiline !== value2.multiline
+                    || value1.sticky !== value2.sticky
+                    || value1.unicode !== value2.unicode
+                    || value1.flags !== value2.flags) {
+                    return { value: true };
+                }
+                continue _props;
+            }
+            if (seen.has(value1))
+                continue _props;
+            if (deep)
+                stack.push({ obj1: value1, obj2: value2 });
+            seen.set(value1, objects);
+        }
+        if (!deep)
+            return { value: false };
+    };
+    _objects: while (stack.length !== 0) {
+        var state_1 = _loop_1();
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return false;
+}
+exports.testDiff = testDiff;

dist/lib/unitTest.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unitTest = void 0;
+// Low budget unit tests instead of Jasmine or Chai
+// Isolates between invocations. Safely contains everything that can go wrong.
+function unitTest(description, testFunction) {
+    var testLog = ["Test run: ".concat(description, ":")];
+    var expectQueue = [];
+    var Expectation = /** @class */ (function () {
+        function Expectation(anyValue) {
+            this.actualValue = anyValue;
+            return this;
+        }
+        Expectation.prototype.toBe = function (expectedValue) {
+            var _this = this;
+            expectQueue.push(function () {
+                if (expectedValue !== _this.actualValue)
+                    throw new Error("Expected ".concat(expectedValue, " but received ").concat(_this.actualValue, " instead."));
+            });
+        };
+        return Expectation;
+    }());
+    function expect(anyValue) {
+        return new Expectation(anyValue);
+    }
+    var caughtError = false;
+    try {
+        testFunction(expect);
+        if (expectQueue.length === 0) {
+            testLog.push("	❓ Test FAIL: No expectations were defined for this test.");
+            process.exitCode = 1;
+            caughtError = true;
+        }
+    }
+    catch (error) {
+        testLog.push("\t\u274C Test FAIL: ".concat(error.toString()));
+        process.exitCode = 1;
+        caughtError = true;
+    }
+    for (var _i = 0, expectQueue_1 = expectQueue; _i < expectQueue_1.length; _i++) {
+        var exp = expectQueue_1[_i];
+        try {
+            exp();
+        }
+        catch (error) {
+            testLog.push("\t\u274C Expectation FAIL: ".concat(error.toString()));
+            process.exitCode = 1;
+            caughtError = true;
+        }
+    }
+    if (!caughtError)
+        testLog.push("	🟢 Test OK!");
+    console.log(testLog.join("\n"));
+}
+exports.unitTest = unitTest;

package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "js-testdiff",
+  "version": "1.0.0",
+  "description": "The \"testDiff\" deep diff/test function from Differentia.js, ported to TypeScript. Returns true if input 1 differs in any way from input 2. Performs deep object search by default, works OK with circular references.",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "npm run build",
+    "build": "tsc src/index.ts src/lib/unitTest.ts --lib es2016 --outDir dist/ && node test.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Floofies/da-testdiff.git"
+  },
+  "keywords": [
+    "test",
+    "diff",
+    "object",
+    "comparison",
+    "compare",
+    "deep",
+    "circular"
+  ],
+  "author": "Dani Glore",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Floofies/da-testdiff/issues"
+  },
+  "homepage": "https://github.com/Floofies/da-testdiff#readme",
+  "devDependencies": {
+    "@types/node": "^18.15.13"
+  }
+}

package.json

@@ -0,0 +1,70 @@
+type searchObj = any|object|Array<any>;
+type objPair = {obj1:searchObj, obj2: searchObj};
+function testValue(value1, value2) {
+	if ((typeof value1) !== (typeof value2))
+		return true;
+	if(Number.isNaN(value1) !== Number.isNaN(value2))
+		return true;
+	if((value1 !== value2))
+		return true;
+}
+// Returns true if obj1 differs in any way from obj2.
+export function testDiff(obj1:searchObj, obj2:searchObj, deep:boolean = true):boolean {
+	if (obj1 === null)
+		return obj1 !== obj2;
+	// Cheap comparisons first
+	if(((typeof obj1) !== "object") && testValue(obj1, obj2))
+		return true;
+	const stack:Array<objPair> = [{ obj1: obj1, obj2: obj2 }];
+	const seen:Map<searchObj, objPair> = new Map();
+	seen.set(obj1, stack[0]);
+	_objects: while (stack.length !== 0) {
+		const objects:objPair = <objPair> stack.pop();
+		if (Array.isArray(objects.obj1) !== Array.isArray(objects.obj2))
+			return true;
+		const props1 = Object.keys(objects.obj1);
+		const props2 = Object.keys(objects.obj2);
+		if (props1.length === 0 && props2.length === 0)
+			continue;
+		if (props1.length !== props2.length)
+			return true;
+		if (!props1.every(value => props2.includes(value)))
+			return true;
+		if (!props2.every(value => props1.includes(value)))
+			return true;
+		_props: for (var loc = 0; loc < props1.length; loc++) {
+			const prop:string = props1[loc];
+			const value1:any = objects.obj1[prop];
+			const value2:any = objects.obj2[prop];
+			if ((typeof value1) !== (typeof value2))
+				return true;
+			if (value1 === null || (typeof value1) !== "object") {
+				if(testValue(value1, value2))
+					return true;
+				continue _props;
+			}
+			if (value1 instanceof RegExp && value2 instanceof RegExp) {
+				if (
+					value1.source !== value2.source
+					|| value1.ignoreCase !== value2.ignoreCase
+					|| value1.global !== value2.global
+					|| value1.multiline !== value2.multiline
+					|| value1.sticky !== value2.sticky
+					|| value1.unicode !== value2.unicode
+					|| value1.flags !== value2.flags
+				) {
+					return true;
+				}
+				continue _props;
+			}
+			if (seen.has(value1))
+				continue _props;
+                        if(deep)
+				stack.push({ obj1: value1, obj2: value2 });
+			seen.set(value1, objects);
+		}
+                if(!deep)
+			return false;
+	}
+	return false;
+}