fixup!

Author: avivkeller

src/generators/api-links/README.md

@@ -6,7 +6,7 @@ The `api-links` generator creates a mapping of publicly accessible functions to
 
 The `api-links` generator accepts the following configuration options:
 
-| Name     | Type      | Default | Description                                         |
-| -------- | --------- | ------- | --------------------------------------------------- |
-| `output` | `string`  | -       | The directory where `apilinks.json` will be written |
-| `minify` | `boolean` | `true`  | Whether to minify the output JSON                   |
+| Name     | Type      | Default                 | Description                                         |
+| -------- | --------- | ----------------------- | --------------------------------------------------- |
+| `output` | `string`  | -                       | The directory where `apilinks.json` will be written |
+| `minify` | `boolean` | Inherited from `global` | Whether to minify the output JSON                   |

src/utils/configuration/index.mjs

@@ -8,7 +8,7 @@ import { allGenerators } from '../../generators/index.mjs';
 import { parseChangelog, parseIndex } from '../../parsers/markdown.mjs';
 import { enforceArray } from '../array.mjs';
 import { leftHandAssign } from '../generators.mjs';
-import { lazy } from '../misc.mjs';
+import { deepMerge, lazy } from '../misc.mjs';
 import { importFromURL } from '../url.mjs';
 
 /**
@@ -39,53 +39,6 @@ export const getDefaultConfig = lazy(() =>
   )
 );
 
-/**
- * Deeply merges multiple objects with special handling for arrays and nested objects.
- *
- * @param {Object[]} objs - Objects to merge, with earlier arguments taking precedence
- * @param {number} maxDepth - Maximum depth for recursive merging
- * @param {number} currentDepth - Current recursion depth
- * @returns {Object} A new object containing the merged result
- */
-const merge = (objs, maxDepth, currentDepth = 0) => {
-  return objs.reduce((result, current) => {
-    return Object.keys({ ...result, ...current }).reduce((acc, k) => {
-      const resultVal = result[k];
-      const currentVal = current[k];
-
-      return {
-        ...acc,
-        [k]:
-          // If both values exist
-          resultVal && currentVal
-            ? // Both are arrays: concatenate them
-              Array.isArray(resultVal) && Array.isArray(currentVal)
-              ? [...resultVal, ...currentVal]
-              : // result is array, current is string: keep result (array wins)
-                Array.isArray(resultVal) && typeof currentVal === 'string'
-                ? resultVal.concat([currentVal])
-                : // result is string, current is array: keep current (array wins)
-                  typeof resultVal === 'string' && Array.isArray(currentVal)
-                  ? currentVal.concat([resultVal])
-                  : // Both are objects: recursively merge if depth allows
-                    typeof resultVal === 'object' &&
-                      typeof currentVal === 'object'
-                    ? currentDepth < maxDepth
-                      ? merge(
-                          [resultVal, currentVal],
-                          maxDepth,
-                          currentDepth + 1
-                        )
-                      : currentVal // At max depth, use current value (last wins)
-                    : // Otherwise: result takes precedence
-                      resultVal
-            : // Only one exists: use nullish coalescing to pick the defined value
-              (resultVal ?? currentVal),
-      };
-    }, {});
-  }, {});
-};
-
 /**
  * Loads a configuration file from a URL or file path.
  *
@@ -158,11 +111,10 @@ export const createRunConfiguration = async options => {
   config.target &&= enforceArray(config.target);
 
   // Merge with defaults
-  // We set maxDepth as 2, as that's the depth of
-  // our object.
-  const merged = merge(
-    [config, createConfigFromCLIOptions(options), getDefaultConfig()],
-    1
+  const merged = deepMerge(
+    config,
+    createConfigFromCLIOptions(options),
+    getDefaultConfig()
   );
 
   // These need to be coerced

src/utils/misc.mjs

@@ -1,9 +1,51 @@
 /**
- * Lazy-loader
+ * Creates a lazy-initialized function that caches the result of the first invocation.
+ * @template {(...args: any[]) => any} T
+ * @param {T} fn - The function to be lazily executed
+ * @returns {T} A wrapper function that lazily executes fn and caches its result
  */
 export const lazy = fn =>
   (
     c =>
     (...args) =>
       (c ??= fn(...args))
   )();
+
+/**
+ * Checks if a value is a plain JavaScript object.
+ * @param {*} value - The value to check
+ * @returns {boolean} True if the value is a plain object, false otherwise
+ */
+export const isPlainObject = value =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/**
+ * Recursively merges multiple objects deeply.
+ * @template T
+ * @param {...T} objects - Any number of objects to merge
+ * @returns {T} A new object containing the deep merge of all provided objects
+ */
+export const deepMerge = (...objects) => {
+  const base = objects.pop();
+
+  return objects.reduce((result, source) => {
+    // Skip null/undefined values
+    if (!source) {
+      return result;
+    }
+
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+
+        result[key] =
+          isPlainObject(targetValue) && isPlainObject(sourceValue)
+            ? deepMerge(targetValue, sourceValue, base[key])
+            : sourceValue;
+      }
+    }
+
+    return result;
+  }, base);
+};