@vijayhardaha/dev-config 2.2.0 → 2.3.0

package/src/eslint/lib/plugin-helpers/parser.js

@@ -0,0 +1,33 @@
+/**
+ * Removes the parser from individual configs when main config provides one.
+ *
+ * Prevents parser conflicts (e.g., eslint-config-next/parser vs \@typescript-eslint/parser).
+ * Cleans up empty languageOptions objects after parser removal.
+ *
+ * @param {Array<object>} flatConfigs - Flat config array.
+ *
+ * @returns {Array<object>} Config array with parsers removed.
+ *
+ * @example
+ * const stripped = stripParser([
+ *   {
+ *     languageOptions: {
+ *       parser: typescriptParser,
+ *       sourceType: 'module'
+ *     }
+ *   }
+ * ]);
+ * // Returns: [{ languageOptions: { sourceType: 'module' } }]
+ */
+export function stripParser(flatConfigs) {
+  return flatConfigs.map((config) => {
+    if (!config.languageOptions?.parser) return config;
+
+    const languageOptions = { ...config.languageOptions };
+    delete languageOptions.parser;
+
+    return Object.keys(languageOptions).length > 0
+      ? { ...config, languageOptions }
+      : { ...config, languageOptions: undefined };
+  });
+}

package/src/eslint/lib/plugin-helpers/strip.js

@@ -0,0 +1,45 @@
+/**
+ * Removes centrally-registered plugins from individual configs.
+ *
+ * Prevents "Cannot redefine plugin" errors when plugins are registered
+ * at the root config level. Removes plugins by name from nested configs.
+ *
+ * @param {Array<object>} flatConfigs - Flat config array.
+ * @param {Array<string>} pluginNames - Plugin names to strip from configs.
+ *
+ * @returns {Array<object>} Config array with specified plugins removed.
+ *
+ * @example
+ * const stripped = stripPlugins(
+ *   [
+ *     { plugins: { prettier: prettierPlugin, eslint: eslintPlugin } },
+ *     { plugins: { prettier: prettierPlugin } }
+ *   ],
+ *   ['prettier']
+ * );
+ * // prettier plugin removed from both configs
+ */
+export function stripPlugins(flatConfigs, pluginNames) {
+  if (pluginNames.length === 0) return flatConfigs;
+
+  const skip = new Set(pluginNames);
+
+  return flatConfigs.map((config) => {
+    if (!config.plugins) return config;
+
+    const plugins = { ...config.plugins };
+
+    for (const name of skip) {
+      delete plugins[name];
+    }
+
+    if (Object.keys(plugins).length === 0) {
+      const rest = { ...config };
+      delete rest.plugins;
+
+      return rest;
+    }
+
+    return { ...config, plugins };
+  });
+}

package/src/gulp-smacss/{index.test.js → __tests__/index.test.js}

@@ -3,13 +3,13 @@ import { describe, it, expect } from 'vitest';
 // Test suite for the gulp-smacss module.
 describe('gulp-smacss/index.js', () => {
   it('should export smacssOrder array', async () => {
-    const module = await import('./index.js');
+    const module = await import('../index.js');
 
     expect(Array.isArray(module.smacssOrder)).toBe(true);
   });
 
   it('should include expected SMACSS properties in the order', async () => {
-    const module = await import('./index.js');
+    const module = await import('../index.js');
 
     expect(module.smacssOrder).toContain('position');
     expect(module.smacssOrder).toContain('display');

package/src/gulp-smacss/index.js

@@ -249,6 +249,11 @@ const other = [
 ];
 
 // ── Final merged order (SMACSS) ──
+/**
+ * Ordered CSS property groups following the SMACSS methodology.
+ *
+ * @type {string[]}
+ */
 export const smacssOrder = [
   ...positioning,
   ...displayVisibility,

package/src/jsconfig/{index.test.js → __tests__/index.test.js}

@@ -5,7 +5,7 @@ describe('jsconfig/index.json', () => {
   // Test that the jsconfig file is valid JSON and exports an object.
   it('should be a valid JSON file', async () => {
     // Dynamically import the JSON file with JSON assertion.
-    const module = await import('./index.json', { assert: { type: 'json' } });
+    const module = await import('../index.json', { assert: { type: 'json' } });
 
     // Verify that the default export is an object (valid JSON object).
     expect(typeof module.default).toBe('object');
@@ -14,7 +14,7 @@ describe('jsconfig/index.json', () => {
   // Test that the jsconfig contains compilerOptions.
   it('should have compilerOptions', async () => {
     // Dynamically import the JSON file with JSON assertion.
-    const module = await import('./index.json', { assert: { type: 'json' } });
+    const module = await import('../index.json', { assert: { type: 'json' } });
 
     // Verify that compilerOptions property exists on the config object.
     expect(module.default.compilerOptions).toBeDefined();
@@ -26,7 +26,7 @@ describe('jsconfig/index.json', () => {
   // Test that the jsconfig has exclude patterns defined as an array.
   it('should have exclude patterns', async () => {
     // Dynamically import the JSON file with JSON assertion.
-    const module = await import('./index.json', { assert: { type: 'json' } });
+    const module = await import('../index.json', { assert: { type: 'json' } });
 
     // Verify that exclude property exists and is an array (list of file patterns to exclude).
     expect(Array.isArray(module.default.exclude)).toBe(true);

package/src/lib/__tests__/config-utils.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  mergeDeep,
+  filterObjectEntries,
+  createFileOverride,
+  getNestedValue,
+  setNestedValue,
+  flattenArray,
+  compactArray,
+  isPlainObject,
+} from '../config-utils.js';
+
+describe('Config Utils', () => {
+  describe('mergeDeep', () => {
+    it('should merge objects deeply', () => {
+      const result = mergeDeep({ a: { b: 1 } }, { a: { c: 2 } });
+      expect(result).toEqual({ a: { b: 1, c: 2 } });
+    });
+
+    it('should override values', () => {
+      const result = mergeDeep({ a: 1 }, { a: 2 });
+      expect(result).toEqual({ a: 2 });
+    });
+
+    it('should handle multiple sources', () => {
+      const result = mergeDeep({ a: 1 }, { b: 2 }, { c: 3 });
+      expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it('should replace arrays instead of merging', () => {
+      const result = mergeDeep({ arr: [1, 2] }, { arr: [3] });
+      expect(result).toEqual({ arr: [3] });
+    });
+  });
+
+  describe('filterObjectEntries', () => {
+    it('should filter object entries', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      const result = filterObjectEntries(obj, ([key]) => key !== 'b');
+      expect(result).toEqual({ a: 1, c: 3 });
+    });
+
+    it('should filter by value', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      const result = filterObjectEntries(obj, ([, value]) => value > 1);
+      expect(result).toEqual({ b: 2, c: 3 });
+    });
+  });
+
+  describe('createFileOverride', () => {
+    it('should create file override config', () => {
+      const result = createFileOverride(['*.py'], { tabWidth: 4 });
+      expect(result).toEqual({ files: ['*.py'], options: { tabWidth: 4 } });
+    });
+  });
+
+  describe('getNestedValue', () => {
+    it('should get nested value with dot notation', () => {
+      const obj = { a: { b: { c: 42 } } };
+      expect(getNestedValue(obj, 'a.b.c')).toBe(42);
+    });
+
+    it('should return default if path not found', () => {
+      const obj = { a: { b: 1 } };
+      expect(getNestedValue(obj, 'a.b.c.d', 'default')).toBe('default');
+    });
+
+    it('should handle undefined as default', () => {
+      const obj = {};
+      expect(getNestedValue(obj, 'a.b')).toBeUndefined();
+    });
+  });
+
+  describe('setNestedValue', () => {
+    it('should set nested value with dot notation', () => {
+      const obj = {};
+      setNestedValue(obj, 'a.b.c', 42);
+      expect(obj).toEqual({ a: { b: { c: 42 } } });
+    });
+
+    it('should create intermediate objects', () => {
+      const obj = { a: {} };
+      setNestedValue(obj, 'a.b.c.d', 'value');
+      expect(obj.a.b.c.d).toBe('value');
+    });
+
+    it('should return modified object', () => {
+      const obj = {};
+      const result = setNestedValue(obj, 'x', 1);
+      expect(result).toBe(obj);
+    });
+  });
+
+  describe('flattenArray', () => {
+    it('should flatten arrays', () => {
+      const result = flattenArray([1, [2, 3], 4]);
+      expect(result).toEqual([1, 2, 3, 4]);
+    });
+
+    it('should handle mixed arrays and objects', () => {
+      const result = flattenArray([{ a: 1 }, [{ b: 2 }, { c: 3 }]]);
+      expect(result).toEqual([{ a: 1 }, { b: 2 }, { c: 3 }]);
+    });
+  });
+
+  describe('compactArray', () => {
+    it('should remove falsy values', () => {
+      const result = compactArray([1, null, 2, undefined, 3, false, 0, '', 4]);
+      expect(result).toEqual([1, 2, 3, 4]);
+    });
+
+    it('should keep truthy values', () => {
+      const result = compactArray([true, 'string', {}, [], 1]);
+      expect(result).toEqual([true, 'string', {}, [], 1]);
+    });
+  });
+
+  describe('isPlainObject', () => {
+    it('should identify plain objects', () => {
+      expect(isPlainObject({})).toBe(true);
+      expect(isPlainObject({ a: 1 })).toBe(true);
+    });
+
+    it('should reject arrays', () => {
+      expect(isPlainObject([])).toBe(false);
+    });
+
+    it('should reject null', () => {
+      expect(isPlainObject(null)).toBe(false);
+    });
+
+    it('should reject special objects', () => {
+      expect(isPlainObject(new Date())).toBe(false);
+      expect(isPlainObject(/regex/)).toBe(false);
+      expect(isPlainObject(new Map())).toBe(false);
+    });
+
+    it('should reject primitives', () => {
+      expect(isPlainObject('string')).toBe(false);
+      expect(isPlainObject(42)).toBe(false);
+      expect(isPlainObject(true)).toBe(false);
+    });
+  });
+});

package/src/lib/__tests__/validators.test.js

@@ -0,0 +1,229 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  validateUrl,
+  validateArray,
+  validateNonEmptyArray,
+  validateObject,
+  validateString,
+  validateNonEmptyString,
+  validateBoolean,
+  validateNumber,
+  validateNumberInRange,
+  validateStringArray,
+  validateObjectKeys,
+  validateRules,
+  validateFilePatterns,
+} from '../validators.js';
+
+describe('Validators', () => {
+  describe('validateUrl', () => {
+    it('should accept valid URLs', () => {
+      expect(() => validateUrl('https://example.com')).not.toThrow();
+      expect(() => validateUrl('http://localhost:3000')).not.toThrow();
+    });
+
+    it('should reject non-string URLs', () => {
+      expect(() => validateUrl(123)).toThrow(TypeError);
+      expect(() => validateUrl(null)).toThrow(TypeError);
+    });
+
+    it('should reject empty URLs', () => {
+      expect(() => validateUrl('')).toThrow(Error);
+      expect(() => validateUrl('   ')).toThrow(Error);
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(() => validateUrl('not a url')).toThrow(Error);
+      expect(() => validateUrl('ht!@#tp://invalid')).toThrow(Error);
+    });
+
+    it('should use custom field name in error', () => {
+      expect(() => validateUrl('invalid', 'Sitemap URL')).toThrow(/Sitemap URL/);
+    });
+  });
+
+  describe('validateArray', () => {
+    it('should accept arrays', () => {
+      expect(() => validateArray([])).not.toThrow();
+      expect(() => validateArray([1, 2, 3])).not.toThrow();
+    });
+
+    it('should reject non-arrays', () => {
+      expect(() => validateArray('not an array')).toThrow(TypeError);
+      expect(() => validateArray({ array: true })).toThrow(TypeError);
+    });
+  });
+
+  describe('validateNonEmptyArray', () => {
+    it('should accept non-empty arrays', () => {
+      expect(() => validateNonEmptyArray([1])).not.toThrow();
+    });
+
+    it('should reject empty arrays', () => {
+      expect(() => validateNonEmptyArray([])).toThrow(Error);
+    });
+
+    it('should reject non-arrays', () => {
+      expect(() => validateNonEmptyArray('not an array')).toThrow(TypeError);
+    });
+  });
+
+  describe('validateObject', () => {
+    it('should accept objects', () => {
+      expect(() => validateObject({})).not.toThrow();
+      expect(() => validateObject({ key: 'value' })).not.toThrow();
+    });
+
+    it('should reject non-objects', () => {
+      expect(() => validateObject('string')).toThrow(TypeError);
+      expect(() => validateObject(123)).toThrow(TypeError);
+    });
+
+    it('should reject arrays', () => {
+      expect(() => validateObject([1, 2, 3])).toThrow(TypeError);
+    });
+
+    it('should reject null', () => {
+      expect(() => validateObject(null)).toThrow(TypeError);
+    });
+  });
+
+  describe('validateString', () => {
+    it('should accept strings', () => {
+      expect(() => validateString('hello')).not.toThrow();
+      expect(() => validateString('')).not.toThrow();
+    });
+
+    it('should reject non-strings', () => {
+      expect(() => validateString(123)).toThrow(TypeError);
+      expect(() => validateString(null)).toThrow(TypeError);
+    });
+  });
+
+  describe('validateNonEmptyString', () => {
+    it('should accept non-empty strings', () => {
+      expect(() => validateNonEmptyString('hello')).not.toThrow();
+    });
+
+    it('should reject empty strings', () => {
+      expect(() => validateNonEmptyString('')).toThrow(Error);
+      expect(() => validateNonEmptyString('   ')).toThrow(Error);
+    });
+
+    it('should reject non-strings', () => {
+      expect(() => validateNonEmptyString(123)).toThrow(TypeError);
+    });
+  });
+
+  describe('validateBoolean', () => {
+    it('should accept booleans', () => {
+      expect(() => validateBoolean(true)).not.toThrow();
+      expect(() => validateBoolean(false)).not.toThrow();
+    });
+
+    it('should reject non-booleans', () => {
+      expect(() => validateBoolean(1)).toThrow(TypeError);
+      expect(() => validateBoolean('true')).toThrow(TypeError);
+    });
+  });
+
+  describe('validateNumber', () => {
+    it('should accept valid numbers', () => {
+      expect(() => validateNumber(42)).not.toThrow();
+      expect(() => validateNumber(0)).not.toThrow();
+      expect(() => validateNumber(-5)).not.toThrow();
+    });
+
+    it('should reject non-numbers', () => {
+      expect(() => validateNumber('42')).toThrow(TypeError);
+      expect(() => validateNumber(null)).toThrow(TypeError);
+    });
+
+    it('should reject NaN and Infinity', () => {
+      expect(() => validateNumber(NaN)).toThrow(TypeError);
+      expect(() => validateNumber(Infinity)).toThrow(TypeError);
+    });
+  });
+
+  describe('validateNumberInRange', () => {
+    it('should accept numbers within range', () => {
+      expect(() => validateNumberInRange(0.5, 0, 1)).not.toThrow();
+      expect(() => validateNumberInRange(0, 0, 1)).not.toThrow();
+      expect(() => validateNumberInRange(1, 0, 1)).not.toThrow();
+    });
+
+    it('should reject numbers outside range', () => {
+      expect(() => validateNumberInRange(-0.5, 0, 1)).toThrow(Error);
+      expect(() => validateNumberInRange(1.5, 0, 1)).toThrow(Error);
+    });
+
+    it('should reject non-numbers', () => {
+      expect(() => validateNumberInRange('0.5', 0, 1)).toThrow(TypeError);
+    });
+  });
+
+  describe('validateStringArray', () => {
+    it('should accept arrays of strings', () => {
+      expect(() => validateStringArray(['a', 'b', 'c'])).not.toThrow();
+      expect(() => validateStringArray([])).not.toThrow();
+    });
+
+    it('should reject arrays with non-strings', () => {
+      expect(() => validateStringArray(['a', 123])).toThrow(TypeError);
+    });
+
+    it('should reject non-arrays', () => {
+      expect(() => validateStringArray('not an array')).toThrow(TypeError);
+    });
+  });
+
+  describe('validateObjectKeys', () => {
+    it('should accept objects with required keys', () => {
+      expect(() => validateObjectKeys({ name: 'test' }, ['name'])).not.toThrow();
+      expect(() => validateObjectKeys({ name: 'test', age: 30 }, ['name', 'age'])).not.toThrow();
+    });
+
+    it('should accept objects with extra keys', () => {
+      expect(() => validateObjectKeys({ name: 'test', age: 30 }, ['name'])).not.toThrow();
+    });
+
+    it('should reject objects missing required keys', () => {
+      expect(() => validateObjectKeys({ name: 'test' }, ['name', 'age'])).toThrow(Error);
+    });
+
+    it('should reject non-objects', () => {
+      expect(() => validateObjectKeys('not an object', ['key'])).toThrow(TypeError);
+    });
+  });
+
+  describe('validateRules', () => {
+    it('should accept rules objects', () => {
+      expect(() => validateRules({ 'rule-name': 'error' })).not.toThrow();
+      expect(() => validateRules({})).not.toThrow();
+    });
+
+    it('should reject non-objects', () => {
+      expect(() => validateRules('not an object')).toThrow(TypeError);
+    });
+
+    it('should reject arrays', () => {
+      expect(() => validateRules(['rule1', 'rule2'])).toThrow(TypeError);
+    });
+  });
+
+  describe('validateFilePatterns', () => {
+    it('should accept valid file patterns', () => {
+      expect(() => validateFilePatterns(['**/*.js'])).not.toThrow();
+      expect(() => validateFilePatterns(['**/*.js', '**/*.ts', '**/*.jsx'])).not.toThrow();
+    });
+
+    it('should reject arrays with non-strings', () => {
+      expect(() => validateFilePatterns(['**/*.js', 123])).toThrow(TypeError);
+    });
+
+    it('should reject non-arrays', () => {
+      expect(() => validateFilePatterns('**/*.js')).toThrow(TypeError);
+    });
+  });
+});

package/src/lib/config-utils.js

@@ -0,0 +1,187 @@
+/**
+ * =====================================================================
+ * Configuration Utilities
+ * =====================================================================
+ * Purpose: Shared utility functions for configuration builders.
+ *          Common patterns used across multiple config modules.
+ * Usage:   Import and use in config builders
+ * =====================================================================
+ */
+
+/**
+ * Deep merge two objects with override capability.
+ *
+ * Later values override earlier values. Arrays are replaced, not merged.
+ *
+ * @param {object} target - Target object.
+ * @param {...object} sources - Source objects to merge.
+ *
+ * @returns {object} Merged object.
+ *
+ * @example
+ * const merged = mergeDeep(
+ *   { a: 1, nested: { b: 2 } },
+ *   { nested: { c: 3 } }
+ * );
+ * // Returns: { a: 1, nested: { b: 2, c: 3 } }
+ */
+export function mergeDeep(target, ...sources) {
+  if (sources.length === 0) return target;
+
+  const source = sources.shift();
+
+  if (typeof target !== 'object' || target === null || typeof source !== 'object' || source === null) {
+    return mergeDeep(target, ...sources);
+  }
+
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      if (!(key in target)) target[key] = {};
+      mergeDeep(target[key], value);
+      continue;
+    }
+
+    target[key] = value;
+  }
+
+  return mergeDeep(target, ...sources);
+}
+
+/**
+ * Filter object entries by a predicate function.
+ *
+ * @param {object} obj - Object to filter.
+ * @param {(entry: [string, unknown], index: number, entries: [string, unknown][]) => boolean} predicate - Function that returns true to keep entries.
+ *
+ * @returns {object} Filtered object.
+ *
+ * @example
+ * const filtered = filterObjectEntries(
+ *   { a: 1, b: 2, c: 3 },
+ *   ([key]) => key !== 'b'
+ * );
+ * // Returns: { a: 1, c: 3 }
+ */
+export function filterObjectEntries(obj, predicate) {
+  return Object.fromEntries(Object.entries(obj).filter(predicate));
+}
+
+/**
+ * Create a configuration override for specific file patterns.
+ *
+ * @param {string[]} files - File patterns to match.
+ * @param {object} options - Override options.
+ *
+ * @returns {object} Override configuration object.
+ *
+ * @example
+ * const override = createFileOverride(['*.py'], { tabWidth: 4 });
+ * // Returns: { files: ['*.py'], options: { tabWidth: 4 } }
+ */
+export function createFileOverride(files, options) {
+  return { files, options };
+}
+
+/**
+ * Get a nested property from an object using dot notation.
+ *
+ * @param {object} obj - Object to search.
+ * @param {string} path - Dot-notated path (e.g., 'a.b.c').
+ * @param {(object | Array | string | number | boolean | null | undefined)} [defaultValue] - Value if path not found.
+ *
+ * @returns {(object | Array | string | number | boolean | null | undefined)} Property value or default.
+ *
+ * @example
+ * const value = getNestedValue({ a: { b: { c: 42 } } }, 'a.b.c');
+ * // Returns: 42
+ */
+export function getNestedValue(obj, path, defaultValue = undefined) {
+  const keys = path.split('.');
+  let current = obj;
+
+  for (const key of keys) {
+    if (typeof current === 'object' && current !== null && key in current) {
+      current = current[key];
+    } else {
+      return defaultValue;
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Set a nested property in an object using dot notation.
+ *
+ * @param {object} obj - Object to modify.
+ * @param {string} path - Dot-notated path (e.g., 'a.b.c').
+ * @param {(object | Array | string | number | boolean | null)} value - Value to set.
+ *
+ * @returns {object} Modified object.
+ *
+ * @example
+ * const obj = {};
+ * setNestedValue(obj, 'a.b.c', 42);
+ * // obj is now: { a: { b: { c: 42 } } }
+ */
+export function setNestedValue(obj, path, value) {
+  const keys = path.split('.');
+  let current = obj;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== 'object' || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+  return obj;
+}
+
+/**
+ * Flatten an array of mixed arrays and objects.
+ *
+ * @param {Array} arr - Array to flatten (shallow).
+ *
+ * @returns {Array} Flattened array.
+ *
+ * @example
+ * const flat = flattenArray([1, [2, 3], 4]);
+ * // Returns: [1, 2, 3, 4]
+ */
+export function flattenArray(arr) {
+  return arr.reduce((acc, item) => (Array.isArray(item) ? acc.concat(item) : acc.concat([item])), []);
+}
+
+/**
+ * Remove falsy values from an array.
+ *
+ * @param {Array} arr - Array to clean.
+ *
+ * @returns {Array} Array without falsy values.
+ *
+ * @example
+ * const cleaned = compactArray([1, null, 2, undefined, 3, false]);
+ * // Returns: [1, 2, 3]
+ */
+export function compactArray(arr) {
+  return arr.filter(Boolean);
+}
+
+/**
+ * Check if a value is a plain object (not array, Date, etc.).
+ *
+ * @param {(object | Array | string | number | boolean | null)} value - Value to check.
+ *
+ * @returns {boolean} True if plain object.
+ *
+ * @example
+ * isPlainObject({}) // true
+ * isPlainObject([]) // false
+ * isPlainObject(new Date()) // false
+ */
+export function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}