@instructure/ui-utils 8.52.1-snapshot-6 → 8.52.1-snapshot-11

package/lib/__new-tests__/hash.test.js

@@ -0,0 +1,417 @@
+"use strict";
+
+require("@testing-library/jest-dom");
+var _hash = require("../hash");
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * 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.
+ */
+
+describe('hash', () => {
+  it('should error if supplied value is undefined', () => {
+    let error = false;
+    try {
+      expect((0, _hash.hash)(void 0)).toEqual('');
+    } catch (err) {
+      error = true;
+    }
+    expect(error).toBe(true);
+  });
+  it('should allow specifying a max length', () => {
+    const result = (0, _hash.hash)('some value', 4);
+    expect(result).toBeDefined();
+    expect(result).toHaveLength(4);
+  });
+  describe('strings', () => {
+    it('hashes two identical strings to the same value', () => {
+      const result1 = (0, _hash.hash)('Some string with3_ distinct$() !_)(* va1ues');
+      const result2 = (0, _hash.hash)('Some string with3_ distinct$() !_)(* va1ues');
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes different strings to different values', () => {
+      const result1 = (0, _hash.hash)('Some string with3_ distinct$() !_)(* va1ues');
+      const result2 = (0, _hash.hash)('Some string with3_ distinct$() !_)(* va1ues ');
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+  });
+  describe('numbers', () => {
+    it('hashes two identical numbers to the same value', () => {
+      const result1 = (0, _hash.hash)(532);
+      const result2 = (0, _hash.hash)(532);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two different numbers to different values', () => {
+      const result1 = (0, _hash.hash)(532);
+      const result2 = (0, _hash.hash)(5321);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+  });
+  describe('booleans', () => {
+    it('hashes true to the same value', () => {
+      const result1 = (0, _hash.hash)(true);
+      const result2 = (0, _hash.hash)(true);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes false to the same value', () => {
+      const result1 = (0, _hash.hash)(false);
+      const result2 = (0, _hash.hash)(false);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes true and false to different values', () => {
+      const result1 = (0, _hash.hash)(true);
+      const result2 = (0, _hash.hash)(false);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+  });
+  describe('functions', () => {
+    it('hashes two identical arrow function expressions to the same value', () => {
+      const result1 = (0, _hash.hash)(() => 'foo');
+      const result2 = (0, _hash.hash)(() => 'foo');
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two different arrow function expressions to different values', () => {
+      const result1 = (0, _hash.hash)(() => 'foo');
+      const result2 = (0, _hash.hash)(() => 'bar');
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes two identical functions to the same value', () => {
+      const result1 = (0, _hash.hash)(function myFunc() {
+        const foo = 1;
+        const bar = 2;
+        return foo + bar;
+      });
+      const result2 = (0, _hash.hash)(function myFunc() {
+        const foo = 1;
+        const bar = 2;
+        return foo + bar;
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two identical functions with different names to different values', () => {
+      const result1 = (0, _hash.hash)(function myFunc() {
+        const foo = 1;
+        const bar = 2;
+        return foo + bar;
+      });
+      const result2 = (0, _hash.hash)(function myFunc1() {
+        const foo = 1;
+        const bar = 2;
+        return foo + bar;
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes two identical functions with different bodies to different values', () => {
+      const result1 = (0, _hash.hash)(function myFunc() {
+        const foo = 1;
+        const bar = 2;
+        return foo + bar;
+      });
+      const result2 = (0, _hash.hash)(function myFunc() {
+        const foo = 1;
+        const baz = 2;
+        return foo + baz;
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+  });
+  describe('objects', () => {
+    it('hashes two identical simple objects to the same value', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      });
+      const result2 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two identical simple objects with rearranged keys to the same value', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      });
+      const result2 = (0, _hash.hash)({
+        baz: 'baz',
+        foo: 'foo',
+        bar: 'bar'
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two different simple objects to different values', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      });
+      const result2 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'ba',
+        baz: 'baz'
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes two identical complex objects to the same value', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foo-bar']: true
+        }],
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      const result2 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foo-bar']: true
+        }],
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two identical complex objects with rearranged keys to the same value', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foo-bar']: true
+        }],
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      const result2 = (0, _hash.hash)({
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foo-bar']: true
+        }],
+        foo: 'foo',
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two different simple objects to different values', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      });
+      const result2 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: 'ba',
+        baz: 'baz'
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes two different complex objects to the same value', () => {
+      const result1 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foobar']: true
+        }],
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      const result2 = (0, _hash.hash)({
+        foo: 'foo',
+        bar: [{
+          qux: 'qux',
+          qang: 'qaz'
+        }, {
+          ['foo-bar']: true
+        }],
+        baz: () => {
+          const hello = 'hello';
+          const world = 'world';
+          return hello + world;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+  });
+  describe('classes', () => {
+    it('hashes two identical classes to the same value', () => {
+      const result1 = (0, _hash.hash)(class Something {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      const result2 = (0, _hash.hash)(class Something {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+    it('hashes two classes with different content to different values', () => {
+      const result1 = (0, _hash.hash)(class Something {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      const result2 = (0, _hash.hash)(class Something {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something else';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes two classes with different names to different values', () => {
+      const result1 = (0, _hash.hash)(class Something {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      const result2 = (0, _hash.hash)(class Somethin {
+        constructor(settings) {
+          this._settings = void 0;
+          this.doSomething = () => {
+            return 'doing something';
+          };
+          this._settings = settings;
+        }
+        get settings() {
+          return this._settings;
+        }
+      });
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).not.toEqual(result2);
+    });
+    it('hashes null to the same value', () => {
+      const result1 = (0, _hash.hash)(null);
+      const result2 = (0, _hash.hash)(null);
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result1).toEqual(result2);
+    });
+  });
+});

package/lib/__new-tests__/mergeDeep.test.js

@@ -0,0 +1,198 @@
+"use strict";
+
+require("@testing-library/jest-dom");
+var _mergeDeep = require("../mergeDeep");
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * 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.
+ */
+
+describe('mergeDeep', () => {
+  it('should merge object properties without affecting any object', () => {
+    const obj1 = {
+      a: 0,
+      b: 1
+    };
+    const obj2 = {
+      c: 2,
+      d: 3
+    };
+    const obj3 = {
+      a: 4,
+      d: 5
+    };
+    const expected = {
+      a: 4,
+      b: 1,
+      c: 2,
+      d: 5
+    };
+    expect((0, _mergeDeep.mergeDeep)({}, obj1, obj2, obj3)).toStrictEqual(expected);
+    expect(obj1).not.toStrictEqual(expected);
+    expect(obj2).not.toStrictEqual(expected);
+    expect(obj3).not.toStrictEqual(expected);
+  });
+  it('should do a deep merge', () => {
+    const obj1 = {
+      a: {
+        b: 1,
+        c: 1,
+        d: {
+          e: 1,
+          f: 1
+        }
+      }
+    };
+    const obj2 = {
+      a: {
+        b: 2,
+        d: {
+          f: 'f'
+        }
+      }
+    };
+    expect((0, _mergeDeep.mergeDeep)(obj1, obj2)).toStrictEqual({
+      a: {
+        b: 2,
+        c: 1,
+        d: {
+          e: 1,
+          f: 'f'
+        }
+      }
+    });
+  });
+  it('should not merge strings', () => {
+    const obj1 = {
+      a: 'foo'
+    };
+    const obj2 = {
+      a: {
+        b: 2,
+        d: {
+          f: 'f'
+        }
+      }
+    };
+    const obj3 = {
+      a: 'bar'
+    };
+    const result = (0, _mergeDeep.mergeDeep)(obj1, obj2, obj3);
+    expect(result.a).toEqual('bar');
+  });
+  it('should clone objects during merge', () => {
+    const obj1 = {
+      a: {
+        b: 1
+      }
+    };
+    const obj2 = {
+      a: {
+        c: 2
+      }
+    };
+    const result = (0, _mergeDeep.mergeDeep)({}, obj1, obj2);
+    expect(result).toStrictEqual({
+      a: {
+        b: 1,
+        c: 2
+      }
+    });
+    expect(result.a).not.toStrictEqual(obj1.a);
+    expect(result.a).not.toStrictEqual(obj2.a);
+  });
+  it('should not merge an object into an array', () => {
+    const obj1 = {
+      a: {
+        b: 1
+      }
+    };
+    const obj2 = {
+      a: ['foo', 'bar']
+    };
+    const result = (0, _mergeDeep.mergeDeep)({}, obj1, obj2);
+    expect(result).toStrictEqual({
+      a: ['foo', 'bar']
+    });
+  });
+  it('should deep clone arrays during merge', () => {
+    const obj1 = {
+      a: [1, 2, [3, 4]]
+    };
+    const obj2 = {
+      b: [5, 6]
+    };
+    const result = (0, _mergeDeep.mergeDeep)(obj1, obj2);
+    expect(result.a).toStrictEqual([1, 2, [3, 4]]);
+    expect(result.a[2]).toStrictEqual([3, 4]);
+    expect(result.b).toStrictEqual(obj2.b);
+  });
+  it('should union when both values are array', () => {
+    const obj1 = {
+      a: [1, 2, [3, 4]]
+    };
+    const obj2 = {
+      a: [5, 6]
+    };
+    const result = (0, _mergeDeep.mergeDeep)(obj1, obj2);
+    expect(result.a).toStrictEqual([1, 2, [3, 4], 5, 6]);
+    expect(result.a[2]).toStrictEqual([3, 4]);
+  });
+  it('should union when the first value is an array', () => {
+    const obj1 = {
+      a: [1, 2, [3, 4]]
+    };
+    const obj2 = {
+      a: 5
+    };
+    const obj3 = {
+      a: 6
+    };
+    const result = (0, _mergeDeep.mergeDeep)(obj1, obj2, obj3);
+    expect(result.a).toStrictEqual([1, 2, [3, 4], 5, 6]);
+    expect(result.a[2]).toStrictEqual([3, 4]);
+  });
+  it('should uniquify array values', () => {
+    const obj1 = {
+      a: ['foo']
+    };
+    const obj2 = {
+      a: ['bar']
+    };
+    const obj3 = {
+      a: 'foo'
+    };
+    const result = (0, _mergeDeep.mergeDeep)(obj1, obj2, obj3);
+    expect(result.a).toStrictEqual(['foo', 'bar']);
+  });
+  it('should copy source properties', () => {
+    expect((0, _mergeDeep.mergeDeep)({
+      test: true
+    }).test).toBe(true);
+  });
+  it('should not clone objects created with custom constructor', () => {
+    function TestType() {}
+    // @ts-expect-error intentional "new"
+    const func = new TestType();
+    expect((0, _mergeDeep.mergeDeep)(func)).toEqual(func);
+  });
+});

package/lib/__new-tests__/ms.test.js

@@ -0,0 +1,42 @@
+"use strict";
+
+require("@testing-library/jest-dom");
+var _ms = require("../ms");
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * 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.
+ */
+
+describe('ms', () => {
+  it('handles ms unit', () => {
+    expect((0, _ms.ms)('4ms')).toEqual(4);
+  });
+  it('converts s to ms', () => {
+    expect((0, _ms.ms)('0.3s')).toEqual(0.3 * 1000);
+  });
+  it('handles unitless input', () => {
+    expect((0, _ms.ms)('15')).toEqual(15);
+  });
+  it('handles numeric input', () => {
+    expect((0, _ms.ms)(15)).toEqual(15);
+  });
+});