fix: cjs package paths

dist/cjs/index.js

@@ -0,0 +1,172 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function merge() {
+  return mutate.apply(void 0, [{}].concat(Array.prototype.slice.call(arguments)));
+}
+function clone(target) {
+  if (Array.isArray(target)) {
+    return target.map(function (element) {
+      return clone(element);
+    });
+  } else if (target && _typeof(target) === "object") {
+    return mutate({}, target);
+  } else {
+    return target;
+  }
+}
+function mutate() {
+  var target = arguments[0];
+
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+
+    if (is_object_literal(source)) {
+      if (!is_object_literal(target)) {
+        target = {};
+      }
+
+      for (var _i = 0, _Object$keys = Object.keys(source); _i < _Object$keys.length; _i++) {
+        var name = _Object$keys[_i];
+
+        if (/__proto__|prototype/.test(name)) {
+          // See
+          // https://github.com/adaltas/node-mixme/issues/1
+          // https://github.com/adaltas/node-mixme/issues/2
+          // continue if /__proto__|constructor|prototype|eval|function|\*|\+|;|\s|\(|\)|!/.test name
+          // Unless proven wrong, I consider ok to copy any properties named eval
+          // or function, we are not executing those, only copying.
+          continue;
+        }
+
+        target[name] = mutate(target[name], source[name]);
+      }
+    } else if (Array.isArray(source)) {
+      target = source.map(function (element) {
+        return clone(element);
+      });
+    } else if (source !== undefined) {
+      target = source;
+    }
+  }
+
+  return target;
+}
+function snake_case(source) {
+  var convert = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var target = {};
+
+  if (is_object_literal(source)) {
+    var u = typeof convert === "number" && convert > 0 ? convert - 1 : convert;
+
+    for (var _i2 = 0, _Object$keys2 = Object.keys(source); _i2 < _Object$keys2.length; _i2++) {
+      var name = _Object$keys2[_i2];
+      var src = source[name];
+
+      if (convert) {
+        name = _snake_case(name);
+      }
+
+      target[name] = snake_case(src, u);
+    }
+  } else {
+    target = source;
+  }
+
+  return target;
+}
+function compare(el1, el2) {
+  if (is_object_literal(el1)) {
+    if (!is_object_literal(el2)) {
+      return false;
+    }
+
+    var keys1 = Object.keys(el1).sort();
+    var keys2 = Object.keys(el2).sort();
+
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+
+    for (var i = 0; i < keys1.length; i++) {
+      var key = keys1[i];
+
+      if (key !== keys2[i]) {
+        return false;
+      }
+
+      if (!compare(el1[key], el2[key])) {
+        return false;
+      }
+    }
+  } else if (Array.isArray(el1)) {
+    if (!Array.isArray(el2)) {
+      return false;
+    }
+
+    if (el1.length !== el2.length) {
+      return false;
+    }
+
+    for (var _i3 = 0; _i3 < el1.length; _i3++) {
+      if (!compare(el1[_i3], el2[_i3])) {
+        return false;
+      }
+    }
+  } else if (el1 !== el2) {
+    return false;
+  }
+
+  return true;
+}
+
+function _snake_case(str) {
+  return str.replace(/([A-Z])/g, function (_, match) {
+    return "_" + match.toLowerCase();
+  });
+}
+
+function is_object(obj) {
+  return obj && _typeof(obj) === "object" && !Array.isArray(obj);
+}
+function is_object_literal(obj) {
+  var test = obj;
+
+  if (_typeof(obj) !== "object" || obj === null) {
+    return false;
+  } else {
+    if (Object.getPrototypeOf(test) === null) {
+      return true;
+    }
+
+    while (Object.getPrototypeOf(test = Object.getPrototypeOf(test)) !== null) {
+    }
+
+    return Object.getPrototypeOf(obj) === test;
+  }
+}
+
+exports.clone = clone;
+exports.compare = compare;
+exports.is_object = is_object;
+exports.is_object_literal = is_object_literal;
+exports.merge = merge;
+exports.mutate = mutate;
+exports.snake_case = snake_case;

dist/esm/index.d.ts

@@ -0,0 +1,72 @@
+export function is_object(obj: unknown): boolean;
+export function is_object_literal(obj: unknown): boolean;
+export function compare(el1: unknown, el2: unknown): boolean;
+export function clone<T>(target: T): T;
+
+type Merge<T extends object[]> = T extends [
+  infer Head extends object,
+  ...infer Tail extends object[]
+]
+  ? Tail extends []
+    ? Head
+    : Merge<
+        [
+          MergeObjects<Head, Tail[0]>,
+          ...(Tail extends [infer _, ...infer Rest] ? Rest : [])
+        ]
+      >
+  : never;
+
+// type MergeObjects<T extends object, U extends object> = {
+//   [K in keyof T | keyof U]: K extends keyof T & keyof U
+//     ? T[K] extends object
+//       // Could simplify the code but type negation doesn't seem to work, see
+//       // https://github.com/microsoft/TypeScript/issues/4196
+//       // https://github.com/microsoft/TypeScript/pull/29317
+//       // https://github.com/microsoft/TypeScript/issues/4196
+//       ? U[K] extends object & !Buffer
+//         ? MergeObjects<T[K], U[K]>
+//         : T[K]
+//       : U[K]
+//     : K extends keyof T
+//     ? T[K]
+//     : K extends keyof U
+//     ? U[K]
+//     : never;
+// };
+
+type MergeObjects<T extends object, U extends object> = {
+  [K in keyof T | keyof U]: K extends keyof T & keyof U
+    ? T[K] extends object
+      ? U[K] extends Buffer
+        ? T[K]
+        : U[K] extends object
+          ? MergeObjects<T[K], U[K]>
+          : T[K]
+      : U[K]
+    : K extends keyof T
+    ? T[K]
+    : K extends keyof U
+    ? U[K]
+    : never;
+};
+
+export function merge<T extends object[]>(...args: T): Merge<T>;
+export function mutate<T extends object[]>(...args: T): Merge<T>;
+
+type SnakeCase<S extends string> = S extends `${infer T}${infer U}`
+  ? `${T extends Uppercase<T> ? "_" : ""}${Lowercase<T>}${SnakeCase<U>}`
+  : S;
+
+type SnakeCaseKeys<T> = T extends Array<infer U>
+  ? Array<SnakeCaseKeys<U>>
+  : T extends object
+  ? {
+      [K in keyof T as SnakeCase<string & K>]: SnakeCaseKeys<T[K]>;
+    }
+  : T;
+
+export function snake_case<T extends Record<string, any>>(
+  source: T,
+  convert?: boolean | number
+): SnakeCaseKeys<T>;

package.json

@@ -57,7 +57,7 @@
     "lib"
   ],
   "license": "MIT",
-  "main": "dist/cjs/mixme.js",
+  "main": "./dist/cjs/index.cjs",
   "mocha": {
     "inline-diffs": true,
     "loader": "ts-node/esm",
@@ -78,6 +78,9 @@
     "prepublishOnly": "pinst --disable",
     "postpublish": "pinst --enable",
     "build": "rollup -c && cp lib/index.d.ts dist/cjs/index.d.cts",
+    "build": "npm run build:rollup && npm run build:ts",
+    "build:rollup": "rollup -c",
+    "build:ts": "cp lib/index.d.ts dist/cjs/index.d.cts && cp lib/*.ts dist/esm",
     "test": "mocha 'test/**/*.{js,ts}'",
     "release": "standard-version",
     "release:minor": "standard-version --release-as minor",
@@ -86,5 +89,12 @@
   },
   "type": "module",
   "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/esm/index.d.ts"
+      ]
+    }
+  },
   "dependencies": {}
 }

rollup.config.js

@@ -5,16 +5,16 @@ export default {
   input: 'lib/index.js',
   output: [
     {
-      file: `dist/umd/${pkg.name}.js`,
+      file: `dist/umd/index.js`,
       name: 'mixme',
       format: 'umd'
     },
     {
-      file: `dist/cjs/${pkg.name}.js`,
+      file: `dist/cjs/index.cjs`,
       format: 'cjs'
     },
     {
-      file: `dist/esm/${pkg.name}..js`,
+      file: `dist/esm/index.js`,
       format: 'esm'
     }
   ],