@e22m4u/js-repository 0.1.8 → 0.1.10

package/src/definition/model/properties/property-uniqueness.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Property uniqueness.
+ */
+export declare type PropertyUniqueness = {
+  UNIQUE: true;
+  SPARSE: 'sparse';
+  NON_UNIQUE: false;
+}

package/src/definition/model/properties/property-uniqueness.js

@@ -0,0 +1,8 @@
+/**
+ * Property uniqueness.
+ */
+export const PropertyUniqueness = {
+  UNIQUE: true,
+  SPARSE: 'sparse',
+  NON_UNIQUE: false,
+};

package/src/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './is-ctor.js';
 export * from './capitalize.js';
 export * from './clone-deep.js';
 export * from './singularize.js';
+export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
 export * from './string-to-regexp.js';

package/src/utils/index.js

@@ -2,6 +2,7 @@ export * from './is-ctor.js';
 export * from './capitalize.js';
 export * from './clone-deep.js';
 export * from './singularize.js';
+export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
 export * from './string-to-regexp.js';

package/src/utils/is-deep-equal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Is deep equal.
+ *
+ * @param firstValue
+ * @param secondValue
+ */
+export declare function isDeepEqual(
+  firstValue: unknown,
+  secondValue: unknown,
+): boolean;

package/src/utils/is-deep-equal.js

@@ -0,0 +1,71 @@
+/**
+ * Is deep equal.
+ * https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/69.implement-deep-equal-isEqual.md
+ *
+ * @param {*} firstValue
+ * @param {*} secondValue
+ * @returns {boolean}
+ */
+export function isDeepEqual(firstValue, secondValue) {
+  const cached = new WeakMap();
+  const compare = (a, b) => {
+    // Check if one of the two inputs is primitive by using typeof
+    // operator; since the typeof primitive null is object, check
+    // if one of the inputs is equal to null. If one of the two
+    // inputs is primitive, then I can compare them by reference.
+    if (a === null || b === null) return a === b;
+    if (typeof a !== 'object' || typeof b !== 'object') return a === b;
+    // Check if the data type of the two inputs are the same,
+    // both are arrays or objects. If they are not, return false.
+    const dataTypeA = Array.isArray(a) ? 'array' : 'object';
+    const dataTypeB = Array.isArray(b) ? 'array' : 'object';
+    if (dataTypeA !== dataTypeB) return false;
+    // Use Object.keys and Object.getOwnPropertySymbols to get
+    // all of enumerable and not-inherited properties of the two
+    // inputs. Compare their size respectively, if one of them
+    // is not equal, return false.
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    const symbolsA = Object.getOwnPropertySymbols(a);
+    const symbolsB = Object.getOwnPropertySymbols(b);
+    if (symbolsA.length !== symbolsB.length) return false;
+    // To handle the circular reference, initialize a WeakMap
+    // that is going to keep track of the objects or arrays
+    // that have been seen, in which each key is an object
+    // or an array and each value is a set of objects or arrays,
+    // that have been compared to that object or array.
+    let setForA = cached.get(a);
+    if (setForA == null) {
+      setForA = new Set();
+      cached.set(a, setForA);
+    } else if (setForA.has(b)) {
+      return true;
+    }
+    setForA.add(b);
+    let setForB = cached.get(b);
+    if (setForB == null) {
+      setForB = new Set();
+      cached.set(b, setForB);
+    } else if (setForB.has(a)) {
+      return true;
+    }
+    setForB.add(a);
+    // Compare the property names and the values. Loop through
+    // all the properties of the first input data, check if
+    // the property name also exist in the second input data,
+    // if not, return false; otherwise recursively compare
+    // the property value.
+    const propertyNamesA = [...keysA, ...symbolsA];
+    for (const propertyNameA of propertyNamesA) {
+      if (!b.hasOwnProperty(propertyNameA)) return false;
+      const propertyValueA = a[propertyNameA];
+      const propertyValueB = b[propertyNameA];
+      if (!compare(propertyValueA, propertyValueB)) return false;
+    }
+    // If we get out of the loop without
+    // returning false, return true.
+    return true;
+  };
+  return compare(firstValue, secondValue);
+}

package/src/utils/is-deep-equal.spec.js

@@ -0,0 +1,238 @@
+import {expect} from 'chai';
+import {isDeepEqual} from './is-deep-equal.js';
+
+const check = (a, b, expected) => {
+  expect(isDeepEqual(a, b)).to.be.eq(expected);
+  expect(isDeepEqual(b, a)).to.be.eq(expected);
+};
+
+describe('isDeepEqual', function () {
+  describe('string', function () {
+    it('a non-empty string', function () {
+      check('str', 'str', true);
+      check('str', '', false);
+      check('str', 10, false);
+      check('str', 0, false);
+      check('str', -10, false);
+      check('str', true, false);
+      check('str', false, false);
+      check('str', undefined, false);
+      check('str', null, false);
+      check('str', {foo: 'bar'}, false);
+      check('str', {}, false);
+      check('str', [1, 2, 3], false);
+      check('str', [], false);
+    });
+
+    it('an empty string', function () {
+      check('', 'str', false);
+      check('', '', true);
+      check('', 10, false);
+      check('', 0, false);
+      check('', -10, false);
+      check('', true, false);
+      check('', false, false);
+      check('', undefined, false);
+      check('', null, false);
+      check('', {foo: 'bar'}, false);
+      check('', {}, false);
+      check('', [1, 2, 3], false);
+      check('', [], false);
+    });
+  });
+
+  describe('number', function () {
+    it('a positive number', function () {
+      check(10, 'str', false);
+      check(10, '', false);
+      check(10, 10, true);
+      check(10, 0, false);
+      check(10, -10, false);
+      check(10, true, false);
+      check(10, false, false);
+      check(10, undefined, false);
+      check(10, null, false);
+      check(10, {foo: 'bar'}, false);
+      check(10, {}, false);
+      check(10, [1, 2, 3], false);
+      check(10, [], false);
+    });
+
+    it('zero', function () {
+      check(0, 'str', false);
+      check(0, '', false);
+      check(0, 10, false);
+      check(0, 0, true);
+      check(0, -10, false);
+      check(0, true, false);
+      check(0, false, false);
+      check(0, undefined, false);
+      check(0, null, false);
+      check(0, {foo: 'bar'}, false);
+      check(0, {}, false);
+      check(0, [1, 2, 3], false);
+      check(0, [], false);
+    });
+
+    it('a negative number', function () {
+      check(-10, 'str', false);
+      check(-10, '', false);
+      check(-10, 10, false);
+      check(-10, 0, false);
+      check(-10, -10, true);
+      check(-10, true, false);
+      check(-10, false, false);
+      check(-10, undefined, false);
+      check(-10, null, false);
+      check(-10, {foo: 'bar'}, false);
+      check(-10, {}, false);
+      check(-10, [1, 2, 3], false);
+      check(-10, [], false);
+    });
+  });
+
+  describe('boolean', function () {
+    it('true', function () {
+      check(true, 'str', false);
+      check(true, '', false);
+      check(true, 10, false);
+      check(true, 0, false);
+      check(true, -10, false);
+      check(true, true, true);
+      check(true, false, false);
+      check(true, undefined, false);
+      check(true, null, false);
+      check(true, {foo: 'bar'}, false);
+      check(true, {}, false);
+      check(true, [1, 2, 3], false);
+      check(true, [], false);
+    });
+
+    it('false', function () {
+      check(false, 'str', false);
+      check(false, '', false);
+      check(false, 10, false);
+      check(false, 0, false);
+      check(false, -10, false);
+      check(false, true, false);
+      check(false, false, true);
+      check(false, undefined, false);
+      check(false, null, false);
+      check(false, {foo: 'bar'}, false);
+      check(false, {}, false);
+      check(false, [1, 2, 3], false);
+      check(false, [], false);
+    });
+  });
+
+  describe('array', function () {
+    it('an array of numbers', function () {
+      check([1, 2, 3], 'str', false);
+      check([1, 2, 3], '', false);
+      check([1, 2, 3], 10, false);
+      check([1, 2, 3], 0, false);
+      check([1, 2, 3], -10, false);
+      check([1, 2, 3], true, false);
+      check([1, 2, 3], false, false);
+      check([1, 2, 3], undefined, false);
+      check([1, 2, 3], null, false);
+      check([1, 2, 3], {foo: 'bar'}, false);
+      check([1, 2, 3], {}, false);
+      check([1, 2, 3], [1, 2, 3], true);
+      check([1, 2, 3], [], false);
+    });
+
+    it('an empty array', function () {
+      check([], 'str', false);
+      check([], '', false);
+      check([], 10, false);
+      check([], 0, false);
+      check([], -10, false);
+      check([], true, false);
+      check([], false, false);
+      check([], undefined, false);
+      check([], null, false);
+      check([], {foo: 'bar'}, false);
+      check([], {}, false);
+      check([], [1, 2, 3], false);
+      check([], [], true);
+    });
+  });
+
+  describe('object', function () {
+    it('string key and string value', function () {
+      check({foo: 'bar'}, 'str', false);
+      check({foo: 'bar'}, '', false);
+      check({foo: 'bar'}, 10, false);
+      check({foo: 'bar'}, 0, false);
+      check({foo: 'bar'}, -10, false);
+      check({foo: 'bar'}, true, false);
+      check({foo: 'bar'}, false, false);
+      check({foo: 'bar'}, undefined, false);
+      check({foo: 'bar'}, null, false);
+      check({foo: 'bar'}, {foo: 'bar'}, true);
+      check({foo: 'bar'}, {}, false);
+      check({foo: 'bar'}, [1, 2, 3], false);
+      check({foo: 'bar'}, [], false);
+    });
+
+    it('an empty object', function () {
+      check({}, 'str', false);
+      check({}, '', false);
+      check({}, 10, false);
+      check({}, 0, false);
+      check({}, -10, false);
+      check({}, true, false);
+      check({}, false, false);
+      check({}, undefined, false);
+      check({}, null, false);
+      check({}, {foo: 'bar'}, false);
+      check({}, {}, true);
+      check({}, [1, 2, 3], false);
+      check({}, [], false);
+    });
+
+    it('null', function () {
+      check(null, 'str', false);
+      check(null, '', false);
+      check(null, 10, false);
+      check(null, 0, false);
+      check(null, -10, false);
+      check(null, true, false);
+      check(null, false, false);
+      check(null, undefined, false);
+      check(null, null, true);
+      check(null, {foo: 'bar'}, false);
+      check(null, {}, false);
+      check(null, [1, 2, 3], false);
+      check(null, [], false);
+    });
+
+    it('circular reference to itself', function () {
+      const a = {foo: 'bar'};
+      const b = {baz: 'qux'};
+      const c = {foo: 'bar'};
+      a.itself = a;
+      b.itself = b;
+      c.itself = c;
+      check(a, b, false);
+      check(a, c, true);
+    });
+  });
+
+  it('undefined', function () {
+    check(undefined, 'str', false);
+    check(undefined, '', false);
+    check(undefined, 10, false);
+    check(undefined, 0, false);
+    check(undefined, -10, false);
+    check(undefined, true, false);
+    check(undefined, false, false);
+    check(undefined, undefined, true);
+    check(undefined, null, false);
+    check(undefined, {foo: 'bar'}, false);
+    check(undefined, {}, false);
+    check(undefined, [1, 2, 3], false);
+    check(undefined, [], false);
+  });
+});