feat(WorkList): New Study List (WorkList based on ui-next); old study list renamed to LegacyWorklist (#6005)

---------

Co-authored-by: Dan Rukas <dan.rukas@gmail.com>
Co-authored-by: Bill Wallace <wayfarer3130@gmail.com>
This commit is contained in:
authored and GitHub committed 2026-05-28 12:26:30 -04:00
1 parent 9e7a3586ce
commit daae4c144e
121 files changed
+8071 -1468

No files matched your search

@@ -0,0 +1,85 @@
import { shallowEqualIgnoringArrayOrder } from './shallowEqualIgnoringArrayOrder';
describe('shallowEqualIgnoringArrayOrder', () => {
describe('null / undefined handling', () => {
it('treats two nullish values with strict equality', () => {
expect(shallowEqualIgnoringArrayOrder(null, null)).toBe(true);
expect(shallowEqualIgnoringArrayOrder(undefined, undefined)).toBe(true);
// null !== undefined
expect(shallowEqualIgnoringArrayOrder(null, undefined)).toBe(false);
});
it('returns false when only one side is nullish', () => {
expect(shallowEqualIgnoringArrayOrder(null, {})).toBe(false);
expect(shallowEqualIgnoringArrayOrder({}, null)).toBe(false);
expect(shallowEqualIgnoringArrayOrder({ a: 1 }, undefined)).toBe(false);
});
});
describe('scalar values', () => {
it('returns true for equal flat records', () => {
expect(shallowEqualIgnoringArrayOrder({ a: 1, b: 'x' }, { a: 1, b: 'x' })).toBe(true);
});
it('returns true for two empty objects', () => {
expect(shallowEqualIgnoringArrayOrder({}, {})).toBe(true);
});
it('returns false when a scalar value differs', () => {
expect(shallowEqualIgnoringArrayOrder({ a: 1 }, { a: 2 })).toBe(false);
});
it('compares scalars with strict equality (no coercion)', () => {
expect(shallowEqualIgnoringArrayOrder({ a: 1 }, { a: '1' })).toBe(false);
});
});
describe('keys present on only one side', () => {
it('returns false when one object has an extra defined key', () => {
expect(shallowEqualIgnoringArrayOrder({ a: 1 }, { a: 1, b: 2 })).toBe(false);
expect(shallowEqualIgnoringArrayOrder({ a: 1, b: 2 }, { a: 1 })).toBe(false);
});
it('treats a missing key as equal to an explicit undefined value', () => {
// b.y is absent, a.y is undefined — both read as undefined, so equal.
expect(shallowEqualIgnoringArrayOrder({ x: 1, y: undefined }, { x: 1 })).toBe(true);
});
});
describe('array values (order-insensitive)', () => {
it('treats arrays as equal regardless of element order', () => {
expect(shallowEqualIgnoringArrayOrder({ m: [1, 2, 3] }, { m: [3, 1, 2] })).toBe(true);
expect(shallowEqualIgnoringArrayOrder({ m: ['CT', 'MR'] }, { m: ['MR', 'CT'] })).toBe(true);
});
it('returns false when arrays have different lengths', () => {
expect(shallowEqualIgnoringArrayOrder({ m: [1, 2] }, { m: [1, 2, 3] })).toBe(false);
});
it('returns false when arrays of equal length have different elements', () => {
expect(shallowEqualIgnoringArrayOrder({ m: [1, 2] }, { m: [1, 3] })).toBe(false);
});
it('returns false when one value is an array and the other is not', () => {
expect(shallowEqualIgnoringArrayOrder({ m: [1] }, { m: 1 })).toBe(false);
expect(shallowEqualIgnoringArrayOrder({ m: 'CT' }, { m: ['CT'] })).toBe(false);
});
});
describe('shallow-only semantics (documented limitations)', () => {
it('compares nested objects by reference, not structurally', () => {
const shared = { nested: true };
expect(shallowEqualIgnoringArrayOrder({ o: shared }, { o: shared })).toBe(true);
// Equal-looking but distinct references are NOT considered equal.
expect(shallowEqualIgnoringArrayOrder({ o: { nested: true } }, { o: { nested: true } })).toBe(
false
);
});
it('compares arrays as sets, so differing duplicate counts can still be "equal"', () => {
// Same length and same distinct elements, but different multisets.
// The Set-based comparison cannot tell these apart.
expect(shallowEqualIgnoringArrayOrder({ m: [1, 1, 2] }, { m: [1, 2, 2] })).toBe(true);
});
});
});