remove `path` monkey patch

[snebjorn]

Currently path is being monkey patched

orval/packages/core/src/utils/path.ts

Lines 26 to 44 in c658fa3

	for (const [propName, propValue] of Object.entries(basepath)) {
	if (isFunction(propValue)) {
	// @ts-ignore
	path[propName] = ((propName) => {
	return (...args: any[]) => {
	args = args.map((p) => {
	return isString(p) ? toUnix(p) : p;
	});
	// @ts-ignore
	const result = basepath[propName](...args);
	return isString(result) ? toUnix(result) : result;
	};
	})(propName);
	} else {
	// @ts-ignore
	path[propName] = propValue;
	}
	}

While this works, it muddy the waters ☹️

Example:

// example A
import path from 'node:path';

// example B
import path from 'node:path';
import { upath } from '../utils';

Using path will do different things in example A and B.

I took a stab at it a while back, but it's non-obvious (to me) where the real path and the monkey patched path is being used so I focused on other things 😄

[melloware]

@ScriptType any thoughts here?

[melloware]

Looks like it was done with this fix: 6a34606

[snebjorn]

I found this in my stash. I think it's related to this issue 😄

import path from 'node:path';

/**
 * Given two absolute file paths, generates a valid ESM relative import path
 * from the 'importer' file to the 'exporter' file.
 *
 * This function handles path normalization, cross-platform separators, and
 * ensures the path is a valid ESM relative specifier (e.g., starts with './').
 *
 * @param importerFilePath - The absolute path of the file that will contain the import statement.
 * @param exporterFilePath - The absolute path of the file being imported.
 * @param [includeFileExtension=false] - Whether the import path should include the file extension, defaults to false.
 * @returns The relative import path string.
 */
export function getRelativeImportPath(
  importerFilePath: string,
  exporterFilePath: string,
  includeFileExtension = false,
): string {
  if (!path.isAbsolute(importerFilePath))
    throw new Error(
      `'importerFilePath' is not an absolute path. "${importerFilePath}"`,
    );
  if (!path.isAbsolute(exporterFilePath))
    throw new Error(
      `'exporterFilePath' is not an absolute path. "${exporterFilePath}"`,
    );

  // Get the directory of the importer file
  const importerDir = path.dirname(importerFilePath);

  // Calculate the relative path from the importer's directory to the exporter file.
  const relativePath = path.relative(importerDir, exporterFilePath);

  // Convert to posix path
  let posixPath = path.posix.join(...relativePath.split(path.sep));

  // Ensure the path starts with './' for same-directory imports.
  // A relative specifier must start with '/', './', or '../'.
  if (!posixPath.startsWith('./') && !posixPath.startsWith('../')) {
    posixPath = `./${posixPath}`;
  }

  if (!includeFileExtension) {
    posixPath = posixPath.replace(
      new RegExp(`${path.extname(posixPath)}$`),
      '',
    );
  }

  return posixPath;
}