src: remove unused getEnvOptionsInputType and getNamespaceOptionsInputType

Author: mertcanaltin

src/node_options.cc

@@ -318,83 +318,6 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,
 
 namespace options_parser {
 
-// Helper function to convert option types to their string representation
-// and add them to a V8 Map
-static bool AddOptionTypeToObject(Isolate* isolate,
-                                  Local<Context> context,
-                                  Local<Object> object,
-                                  const std::string& option_name,
-                                  const OptionMappingDetails& option_details) {
-  std::string type;
-  switch (static_cast<int>(option_details.type)) {
-    case 0:   // No-op
-    case 1:   // V8 flags
-      break;  // V8 and NoOp flags are not supported
-
-    case 2:
-      type = "boolean";
-      break;
-    case 3:  // integer
-    case 4:  // unsigned integer
-    case 6:  // host port
-      type = "number";
-      break;
-    case 5:  // string
-      type = "string";
-      break;
-    case 7:  // string array
-      type = "array";
-      break;
-    default:
-      UNREACHABLE();
-  }
-
-  if (type.empty()) {
-    return true;  // Skip this entry but continue processing
-  }
-
-  Local<String> option_key;
-  if (!String::NewFromUtf8(isolate,
-                           option_name.data(),
-                           v8::NewStringType::kNormal,
-                           option_name.size())
-           .ToLocal(&option_key)) {
-    return true;  // Skip this entry but continue processing
-  }
-
-  Local<String> type_value;
-  if (!String::NewFromUtf8(
-           isolate, type.data(), v8::NewStringType::kNormal, type.size())
-           .ToLocal(&type_value)) {
-    return true;  // Skip this entry but continue processing
-  }
-
-  Local<String> help_text;
-  if (!String::NewFromUtf8(isolate,
-                           option_details.help_text.data(),
-                           v8::NewStringType::kNormal,
-                           option_details.help_text.size())
-           .ToLocal(&help_text)) {
-    return true;  // Skip this entry but continue processing
-  }
-
-  // Create an object with type and help_text properties
-  Local<Value> null_value = Null(isolate);
-  constexpr size_t kOptionInfoLength = 2;
-  std::array<Local<Name>, kOptionInfoLength> names = {
-      String::NewFromUtf8Literal(isolate, "type"),
-      String::NewFromUtf8Literal(isolate, "description")};
-  std::array<Local<Value>, kOptionInfoLength> values = {type_value, help_text};
-  Local<Object> option_info = Object::New(
-      isolate, null_value, names.data(), values.data(), kOptionInfoLength);
-
-  if (object->Set(context, option_key, option_info).IsNothing()) {
-    return false;  // Error occurred, stop processing
-  }
-
-  return true;
-}
-
 class DebugOptionsParser : public OptionsParser<DebugOptions> {
  public:
   DebugOptionsParser();
@@ -2085,109 +2008,6 @@ void GetEmbedderOptions(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(ret);
 }
 
-// This function returns an object containing all the options available
-// as NODE_OPTIONS and their metadata (input type and help text)
-// Example --experimental-transform metadata:
-// { type: kBoolean, help_text: "..." }
-// This is used to determine the type of the input for each option
-// to generate the config file json schema
-void GetEnvOptionsInputType(const FunctionCallbackInfo<Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-  Local<Context> context = isolate->GetCurrentContext();
-  Environment* env = Environment::GetCurrent(context);
-
-  if (!env->has_run_bootstrapping_code()) {
-    // No code because this is an assertion.
-    THROW_ERR_OPTIONS_BEFORE_BOOTSTRAPPING(
-        isolate, "Should not query options before bootstrapping is done");
-  }
-
-  Mutex::ScopedLock lock(per_process::cli_options_mutex);
-
-  Local<Object> options_metadata = Object::New(isolate);
-
-  for (const auto& item : _ppop_instance.options_) {
-    if (!item.first.empty() && !item.first.starts_with('[') &&
-        item.second.env_setting == kAllowedInEnvvar) {
-      const auto mapping_details = options_parser::OptionMappingDetails{
-          item.second.type,
-          item.second.help_text,
-      };
-      if (!AddOptionTypeToObject(isolate,
-                                 context,
-                                 options_metadata,
-                                 item.first,
-                                 mapping_details)) {
-        return;
-      }
-    }
-  }
-  args.GetReturnValue().Set(options_metadata);
-}
-
-// This function returns a two-level nested map where:
-// - Keys are namespace names (e.g., "testRunner")
-// - Values are objects mapping option names to their metadata
-// This is used for config file JSON schema generation
-void GetNamespaceOptionsInputType(const FunctionCallbackInfo<Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-  Local<Context> context = isolate->GetCurrentContext();
-  Environment* env = Environment::GetCurrent(context);
-
-  if (!env->has_run_bootstrapping_code()) {
-    // No code because this is an assertion.
-    THROW_ERR_OPTIONS_BEFORE_BOOTSTRAPPING(
-        isolate, "Should not query options before bootstrapping is done");
-  }
-
-  Mutex::ScopedLock lock(per_process::cli_options_mutex);
-
-  Local<Map> namespaces_metadata = Map::New(isolate);
-
-  // Get the mapping of namespaces to their options and metadata
-  auto namespace_options = options_parser::MapNamespaceOptionsAssociations();
-
-  for (const auto& ns_entry : namespace_options) {
-    const std::string& namespace_name = ns_entry.first;
-    const auto& options_map = ns_entry.second;
-
-    Local<Object> options_metadata = Object::New(isolate);
-
-    for (const auto& opt_entry : options_map) {
-      const std::string& option_name = opt_entry.first;
-      const options_parser::OptionMappingDetails& option_details =
-          opt_entry.second;
-
-      if (!AddOptionTypeToObject(isolate,
-                                 context,
-                                 options_metadata,
-                                 option_name,
-                                 option_details)) {
-        return;
-      }
-    }
-
-    // Only add namespaces that have options
-    if (!options_metadata.IsEmpty()) {
-      Local<String> namespace_key;
-      if (!String::NewFromUtf8(isolate,
-                               namespace_name.data(),
-                               v8::NewStringType::kNormal,
-                               namespace_name.size())
-               .ToLocal(&namespace_key)) {
-        continue;
-      }
-
-      if (namespaces_metadata->Set(context, namespace_key, options_metadata)
-              .IsEmpty()) {
-        return;
-      }
-    }
-  }
-
-  args.GetReturnValue().Set(namespaces_metadata);
-}
-
 // Return an array containing all currently active options as flag
 // strings from all sources (command line, NODE_OPTIONS, config file)
 void GetOptionsAsFlags(const FunctionCallbackInfo<Value>& args) {
@@ -2323,12 +2143,6 @@ void Initialize(Local<Object> target,
       context, target, "getOptionsAsFlags", GetOptionsAsFlags);
   SetMethodNoSideEffect(
       context, target, "getEmbedderOptions", GetEmbedderOptions);
-  SetMethodNoSideEffect(
-      context, target, "getEnvOptionsInputType", GetEnvOptionsInputType);
-  SetMethodNoSideEffect(context,
-                        target,
-                        "getNamespaceOptionsInputType",
-                        GetNamespaceOptionsInputType);
   SetMethodNoSideEffect(
       context, target, "getConfigJsonSchema", GetConfigJsonSchema);
   Local<Object> env_settings = Object::New(isolate);
@@ -2357,8 +2171,6 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetCLIOptionsInfo);
   registry->Register(GetOptionsAsFlags);
   registry->Register(GetEmbedderOptions);
-  registry->Register(GetEnvOptionsInputType);
-  registry->Register(GetNamespaceOptionsInputType);
   registry->Register(GetConfigJsonSchema);
 }
 }  // namespace options_parser

src/node_options.h

@@ -666,8 +666,6 @@ class OptionsParser {
   friend std::unordered_map<std::string, OptionMappingDetails>
   MapOptionsByNamespace(std::string namespace_name);
   friend std::vector<std::string> MapAvailableNamespaces();
-  friend void GetEnvOptionsInputType(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
   friend void GetOptionsAsFlags(
       const v8::FunctionCallbackInfo<v8::Value>& args);
 };