js-powerkit 1.0.0

package/tests/objectUtils.test.js

@@ -0,0 +1,211 @@
+import {
+  deepClone,
+  deepMerge,
+  pick,
+  omit,
+  isEmpty,
+  invert,
+  mapKeys,
+  mapValues,
+  defaults,
+  getNestedValue,
+  setNestedValue,
+  getAllKeys,
+  flattenObject,
+  unflattenObject,
+  removeNullish,
+  isEqual,
+  filterObject,
+  toQueryString,
+  fromQueryString,
+  size,
+  has,
+  hasPath
+} from '../src/objectUtils.js';
+
+describe('Object Utilities', () => {
+  describe('deepClone', () => {
+    test('deep clones objects', () => {
+      const obj = { a: 1, b: { c: 2 } };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+      expect(cloned).not.toBe(obj);
+      expect(cloned.b).not.toBe(obj.b);
+    });
+
+    test('handles primitives', () => {
+      expect(deepClone(42)).toBe(42);
+      expect(deepClone('hello')).toBe('hello');
+    });
+  });
+
+  describe('deepMerge', () => {
+    test('merges objects deeply', () => {
+      const obj1 = { a: 1, b: { c: 2 } };
+      const obj2 = { b: { d: 3 }, e: 4 };
+      expect(deepMerge(obj1, obj2)).toEqual({
+        a: 1,
+        b: { c: 2, d: 3 },
+        e: 4
+      });
+      expect(deepMerge({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
+      expect(deepMerge({ a: { b: 1 } }, { a: { c: 2 } })).toEqual({ a: { b: 1, c: 2 } });
+    });
+  });
+
+  describe('pick', () => {
+    test('picks properties', () => {
+      expect(pick({ a: 1, b: 2, c: 3 }, ['a', 'c'])).toEqual({ a: 1, c: 3 });
+    });
+
+    test('throws error for invalid inputs', () => {
+      expect(() => pick(null, ['a'])).toThrow(TypeError);
+      expect(() => pick({}, 'not array')).toThrow(TypeError);
+    });
+  });
+
+  describe('omit', () => {
+    test('omits properties', () => {
+      expect(omit({ a: 1, b: 2, c: 3 }, ['b'])).toEqual({ a: 1, c: 3 });
+    });
+  });
+
+  describe('isEmpty', () => {
+    test('checks if empty', () => {
+      expect(isEmpty({})).toBe(true);
+      expect(isEmpty({ a: 1 })).toBe(false);
+      expect(isEmpty(null)).toBe(false);
+    });
+  });
+
+  describe('invert', () => {
+    test('inverts keys and values', () => {
+      expect(invert({ a: 1, b: 2 })).toEqual({ 1: 'a', 2: 'b' });
+    });
+  });
+
+  describe('mapKeys', () => {
+    test('maps keys', () => {
+      expect(mapKeys({ a: 1, b: 2 }, key => key.toUpperCase())).toEqual({ A: 1, B: 2 });
+    });
+  });
+
+  describe('mapValues', () => {
+    test('maps values', () => {
+      expect(mapValues({ a: 1, b: 2 }, val => val * 2)).toEqual({ a: 2, b: 4 });
+    });
+  });
+
+  describe('defaults', () => {
+    test('sets defaults', () => {
+      expect(defaults({ a: 1 }, { a: 2, b: 3 })).toEqual({ a: 1, b: 3 });
+    });
+  });
+
+  describe('getNestedValue', () => {
+    test('gets nested value', () => {
+      const obj = { a: { b: { c: 42 } } };
+      expect(getNestedValue(obj, 'a.b.c')).toBe(42);
+    });
+
+    test('returns default value when not found', () => {
+      const obj = { a: { b: 1 } };
+      expect(getNestedValue(obj, 'a.c', 'default')).toBe('default');
+    });
+  });
+
+  describe('setNestedValue', () => {
+    test('sets nested value', () => {
+      const obj = { a: { b: 1 } };
+      setNestedValue(obj, 'a.c.d', 42);
+      expect(obj.a.c.d).toBe(42);
+    });
+  });
+
+  describe('getAllKeys', () => {
+    test('gets all nested keys', () => {
+      const obj = { a: 1, b: { c: 2, d: { e: 3 } } };
+      expect(getAllKeys(obj)).toEqual(['a', 'b.c', 'b.d.e']);
+    });
+  });
+
+  describe('flattenObject', () => {
+    test('flattens nested object', () => {
+      const obj = { a: 1, b: { c: 2, d: { e: 3 } } };
+      expect(flattenObject(obj)).toEqual({
+        'a': 1,
+        'b.c': 2,
+        'b.d.e': 3
+      });
+    });
+  });
+
+  describe('unflattenObject', () => {
+    test('unflattens object', () => {
+      const obj = { 'a': 1, 'b.c': 2, 'b.d.e': 3 };
+      expect(unflattenObject(obj)).toEqual({
+        a: 1,
+        b: { c: 2, d: { e: 3 } }
+      });
+    });
+  });
+
+  describe('removeNullish', () => {
+    test('removes null and undefined values', () => {
+      const obj = { a: 1, b: null, c: undefined, d: 0, e: '' };
+      expect(removeNullish(obj)).toEqual({ a: 1, d: 0, e: '' });
+    });
+  });
+
+  describe('isEqual', () => {
+    test('checks deep equality', () => {
+      expect(isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })).toBe(true);
+      expect(isEqual({ a: 1 }, { a: 2 })).toBe(false);
+    });
+  });
+
+  describe('filterObject', () => {
+    test('filters object by predicate', () => {
+      const obj = { a: 1, b: 2, c: 3, d: 4 };
+      expect(filterObject(obj, val => val % 2 === 0)).toEqual({ b: 2, d: 4 });
+    });
+  });
+
+  describe('toQueryString', () => {
+    test('converts object to query string', () => {
+      const obj = { name: 'John', age: 30 };
+      expect(toQueryString(obj)).toBe('name=John&age=30');
+    });
+  });
+
+  describe('fromQueryString', () => {
+    test('converts query string to object', () => {
+      expect(fromQueryString('name=John&age=30')).toEqual({
+        name: 'John',
+        age: '30'
+      });
+    });
+  });
+
+  describe('size', () => {
+    test('returns object size', () => {
+      expect(size({ a: 1, b: 2, c: 3 })).toBe(3);
+      expect(size({})).toBe(0);
+    });
+  });
+
+  describe('has', () => {
+    test('checks property existence', () => {
+      expect(has({ a: 1 }, 'a')).toBe(true);
+      expect(has({ a: 1 }, 'b')).toBe(false);
+    });
+  });
+
+  describe('hasPath', () => {
+    test('checks if path exists', () => {
+      const obj = { a: { b: { c: 1 } } };
+      expect(hasPath(obj, 'a.b.c')).toBe(true);
+      expect(hasPath(obj, 'a.b.d')).toBe(false);
+    });
+  });
+});

package/tests/stringUtils.test.js

@@ -0,0 +1,220 @@
+import {
+  capitalize,
+  toCamelCase,
+  toKebabCase,
+  toSnakeCase,
+  toPascalCase,
+  toTitleCase,
+  reverse,
+  truncate,
+  isPalindrome,
+  mask,
+  slugify,
+  countWords,
+  removeDuplicates,
+  removeWhitespace,
+  extractEmails,
+  extractUrls,
+  stripHtml,
+  escapeHtml,
+  isNumeric,
+  isEmail,
+  isUrl,
+  repeatString
+} from '../src/stringUtils.js';
+
+describe('String Utilities', () => {
+  describe('capitalize', () => {
+    test('capitalizes the first letter', () => {
+      expect(capitalize('hello')).toBe('Hello');
+      expect(capitalize('world')).toBe('World');
+    });
+
+    test('handles empty string', () => {
+      expect(capitalize('')).toBe('');
+    });
+
+    test('throws error for non-string input', () => {
+      expect(() => capitalize(123)).toThrow(TypeError);
+    });
+  });
+
+  describe('toCamelCase', () => {
+    test('converts to camelCase', () => {
+      expect(toCamelCase('hello world')).toBe('helloWorld');
+      expect(toCamelCase('foo-bar')).toBe('fooBar');
+    });
+
+    test('throws error for non-string input', () => {
+      expect(() => toCamelCase(null)).toThrow(TypeError);
+    });
+  });
+
+  describe('toKebabCase', () => {
+    test('converts to kebab-case', () => {
+      expect(toKebabCase('Hello World')).toBe('hello-world');
+      expect(toKebabCase('fooBar')).toBe('foo-bar');
+    });
+  });
+
+  describe('toSnakeCase', () => {
+    test('converts to snake_case', () => {
+      expect(toSnakeCase('Hello World')).toBe('hello_world');
+      expect(toSnakeCase('fooBar')).toBe('foo_bar');
+    });
+  });
+
+  describe('toPascalCase', () => {
+    test('converts to PascalCase', () => {
+      expect(toPascalCase('hello world')).toBe('HelloWorld');
+      expect(toPascalCase('foo-bar')).toBe('FooBar');
+    });
+  });
+
+  describe('toTitleCase', () => {
+    test('converts to title case', () => {
+      expect(toTitleCase('hello world')).toBe('Hello World');
+      expect(toTitleCase('HELLO WORLD')).toBe('Hello World');
+    });
+  });
+
+  describe('reverse', () => {
+    test('reverses the string', () => {
+      expect(reverse('hello')).toBe('olleh');
+      expect(reverse('123')).toBe('321');
+    });
+  });
+
+  describe('truncate', () => {
+    describe('Truncation WITH Suffix (default behavior)', () => {
+      test('truncates string with default suffix', () => {
+        expect(truncate('Hello World', 5)).toBe('He...');
+      });
+
+      test('truncates with custom suffix', () => {
+        expect(truncate('Hello World', 5, '***')).toBe('He***');
+      });
+
+      test('does not truncate if length is sufficient', () => {
+        expect(truncate('Hi', 5)).toBe('Hi');
+      });
+    });
+
+    describe('Truncation WITHOUT Suffix', () => {
+      test('truncates string without suffix when addSuffix is false', () => {
+        expect(truncate('Hello World', 5, '', false)).toBe('Hello');
+      });
+
+      test('should ignore suffix parameter when addSuffix is false', () => {
+        expect(truncate('Hello World', 8, '!!!', false)).toBe('Hello Wo');
+      });
+    });
+  });
+
+  describe('isPalindrome', () => {
+    test('checks if string is palindrome', () => {
+      expect(isPalindrome('racecar')).toBe(true);
+      expect(isPalindrome('hello')).toBe(false);
+      expect(isPalindrome('A man a plan a canal Panama')).toBe(true);
+    });
+  });
+
+  describe('mask', () => {
+    test('masks string', () => {
+      expect(mask('1234567890', 2)).toBe('12******90');
+      expect(mask('secret', 1)).toBe('s****t');
+    });
+  });
+
+  describe('slugify', () => {
+    test('converts to slug', () => {
+      expect(slugify('Hello World!')).toBe('hello-world');
+      expect(slugify('Foo & Bar')).toBe('foo-bar');
+    });
+  });
+
+  describe('countWords', () => {
+    test('counts words', () => {
+      expect(countWords('Hello world')).toBe(2);
+      expect(countWords('One')).toBe(1);
+      expect(countWords('')).toBe(0);
+    });
+  });
+
+  describe('removeDuplicates', () => {
+    test('removes duplicate characters', () => {
+      expect(removeDuplicates('hello')).toBe('helo');
+      expect(removeDuplicates('aaa')).toBe('a');
+    });
+  });
+
+  describe('removeWhitespace', () => {
+    test('removes all whitespace', () => {
+      expect(removeWhitespace('hello world')).toBe('helloworld');
+      expect(removeWhitespace('  hello  world  ')).toBe('helloworld');
+    });
+  });
+
+  describe('extractEmails', () => {
+    test('extracts email addresses', () => {
+      const text = 'Contact us at test@example.com or support@test.org';
+      expect(extractEmails(text)).toEqual(['test@example.com', 'support@test.org']);
+    });
+
+    test('returns empty array when no emails', () => {
+      expect(extractEmails('No emails here')).toEqual([]);
+    });
+  });
+
+  describe('extractUrls', () => {
+    test('extracts URLs', () => {
+      const text = 'Visit https://example.com or http://test.org';
+      expect(extractUrls(text)).toEqual(['https://example.com', 'http://test.org']);
+    });
+  });
+
+  describe('stripHtml', () => {
+    test('removes HTML tags', () => {
+      expect(stripHtml('<p>Hello <b>World</b></p>')).toBe('Hello World');
+      expect(stripHtml('No tags here')).toBe('No tags here');
+    });
+  });
+
+  describe('escapeHtml', () => {
+    test('escapes HTML special characters', () => {
+      expect(escapeHtml('<div>Test & "quotes"</div>'))
+        .toBe('&lt;div&gt;Test &amp; &quot;quotes&quot;&lt;/div&gt;');
+    });
+  });
+
+  describe('isNumeric', () => {
+    test('checks if string is numeric', () => {
+      expect(isNumeric('12345')).toBe(true);
+      expect(isNumeric('123.45')).toBe(false);
+      expect(isNumeric('abc')).toBe(false);
+    });
+  });
+
+  describe('isEmail', () => {
+    test('validates email format', () => {
+      expect(isEmail('test@example.com')).toBe(true);
+      expect(isEmail('invalid.email')).toBe(false);
+      expect(isEmail('')).toBe(false);
+    });
+  });
+
+  describe('isUrl', () => {
+    test('validates URL format', () => {
+      expect(isUrl('https://example.com')).toBe(true);
+      expect(isUrl('http://test.org')).toBe(true);
+      expect(isUrl('not a url')).toBe(false);
+    });
+  });
+
+  describe('repeatString', () => {
+    test('repeats string n times', () => {
+      expect(repeatString('ab', 3)).toBe('ababab');
+      expect(repeatString('x', 0)).toBe('');
+    });
+  });
+});