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

package/src/__new-tests__/hash.test.tsx

@@ -0,0 +1,547 @@
+/*
+ * 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.
+ */
+
+import '@testing-library/jest-dom'
+import { hash } from '../hash'
+
+describe('hash', () => {
+  it('should error if supplied value is undefined', () => {
+    let error = false
+
+    try {
+      expect(hash(undefined)).toEqual('')
+    } catch (err: any) {
+      error = true
+    }
+
+    expect(error).toBe(true)
+  })
+
+  it('should allow specifying a max length', () => {
+    const result = hash('some value', 4)
+    expect(result).toBeDefined()
+    expect(result).toHaveLength(4)
+  })
+
+  describe('strings', () => {
+    it('hashes two identical strings to the same value', () => {
+      const result1 = hash('Some string with3_ distinct$() !_)(* va1ues')
+      const result2 = 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 = hash('Some string with3_ distinct$() !_)(* va1ues')
+      const result2 = 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 = hash(532)
+      const result2 = hash(532)
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+
+    it('hashes two different numbers to different values', () => {
+      const result1 = hash(532)
+      const result2 = hash(5321)
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).not.toEqual(result2)
+    })
+  })
+
+  describe('booleans', () => {
+    it('hashes true to the same value', () => {
+      const result1 = hash(true)
+      const result2 = hash(true)
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+
+    it('hashes false to the same value', () => {
+      const result1 = hash(false)
+      const result2 = hash(false)
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+
+    it('hashes true and false to different values', () => {
+      const result1 = hash(true)
+      const result2 = 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 = hash(() => 'foo')
+      const result2 = hash(() => 'foo')
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+
+    it('hashes two different arrow function expressions to different values', () => {
+      const result1 = hash(() => 'foo')
+      const result2 = hash(() => 'bar')
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).not.toEqual(result2)
+    })
+
+    it('hashes two identical functions to the same value', () => {
+      const result1 = hash(function myFunc() {
+        const foo = 1
+        const bar = 2
+        return foo + bar
+      })
+
+      const result2 = 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 = hash(function myFunc() {
+        const foo = 1
+        const bar = 2
+        return foo + bar
+      })
+
+      const result2 = 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 = hash(function myFunc() {
+        const foo = 1
+        const bar = 2
+        return foo + bar
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: [
+          {
+            qux: 'qux',
+            qang: 'qaz'
+          },
+          {
+            ['foo-bar']: true
+          }
+        ],
+        baz: () => {
+          const hello = 'hello'
+          const world = 'world'
+
+          return hello + world
+        }
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: [
+          {
+            qux: 'qux',
+            qang: 'qaz'
+          },
+          {
+            ['foo-bar']: true
+          }
+        ],
+        baz: () => {
+          const hello = 'hello'
+          const world = 'world'
+
+          return hello + world
+        }
+      })
+
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: 'bar',
+        baz: 'baz'
+      })
+      const result2 = 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 = hash({
+        foo: 'foo',
+        bar: [
+          {
+            qux: 'qux',
+            qang: 'qaz'
+          },
+          {
+            ['foobar']: true
+          }
+        ],
+        baz: () => {
+          const hello = 'hello'
+          const world = 'world'
+
+          return hello + world
+        }
+      })
+
+      const result2 = 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 = hash(
+        class Something {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something'
+          }
+        }
+      )
+
+      const result2 = hash(
+        class Something {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something'
+          }
+        }
+      )
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+
+    it('hashes two classes with different content to different values', () => {
+      const result1 = hash(
+        class Something {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something'
+          }
+        }
+      )
+
+      const result2 = hash(
+        class Something {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something else'
+          }
+        }
+      )
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).not.toEqual(result2)
+    })
+
+    it('hashes two classes with different names to different values', () => {
+      const result1 = hash(
+        class Something {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something'
+          }
+        }
+      )
+
+      const result2 = hash(
+        class Somethin {
+          private _settings: number
+          constructor(settings: number) {
+            this._settings = settings
+          }
+
+          get settings() {
+            return this._settings
+          }
+
+          doSomething = () => {
+            return 'doing something'
+          }
+        }
+      )
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).not.toEqual(result2)
+    })
+
+    it('hashes null to the same value', () => {
+      const result1 = hash(null)
+      const result2 = hash(null)
+
+      expect(result1).toBeDefined()
+      expect(result2).toBeDefined()
+
+      expect(result1).toEqual(result2)
+    })
+  })
+})

package/src/__new-tests__/mergeDeep.test.tsx

@@ -0,0 +1,133 @@
+/*
+ * 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.
+ */
+
+import '@testing-library/jest-dom'
+import { mergeDeep } from '../mergeDeep'
+
+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(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(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 = 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 = 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 = 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 = 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 = 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 = 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 = mergeDeep(obj1, obj2, obj3)
+
+    expect(result.a).toStrictEqual(['foo', 'bar'])
+  })
+
+  it('should copy source properties', () => {
+    expect(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(mergeDeep(func)).toEqual(func)
+  })
+})

package/src/__new-tests__/ms.test.tsx

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+import '@testing-library/jest-dom'
+import { ms } from '../ms'
+
+describe('ms', () => {
+  it('handles ms unit', () => {
+    expect(ms('4ms')).toEqual(4)
+  })
+
+  it('converts s to ms', () => {
+    expect(ms('0.3s')).toEqual(0.3 * 1000)
+  })
+
+  it('handles unitless input', () => {
+    expect(ms('15')).toEqual(15)
+  })
+
+  it('handles numeric input', () => {
+    expect(ms(15)).toEqual(15)
+  })
+})