[JS] Menu Added via Scripting Moves

Question

I've been able to sucessfully add items to the InDesign menu thanks in part to Marijan Tompa's (tomaxxi) blog post http://indisnip.wordpress.com/2010/08/08/create-customized-menu/
My test code (below) creates a new menu, and sucessfully adds two menu items plus a submenu. The submenu is causing me problems. When you first launch InDesign it's created in the proper place (in the middle of the menu). But when you relaunch InDesign, the submenu moves to the top of the menu and never goes back to it's proper position farther down in the menu where it was the first time InDesign was launched.
I've searched high and low in this forum, the web and InDesign's documentation and can't figure out how to keep it from moving (I want the menu to be farther down the menu, not at the top). I hope one of you kind souls will help me to control the position of the submenu (and have it stay there across launches).
Thanks in advance!
Dan
Here's the code I'm working with. This is saved as testMenu.jsx in the Scripts > startup scripts folder.
P.S. I'm testing this in CS5.5 currently, but ideally this solution should work in CS3 and later.
#targetengine "myTestMenu"
var myFolder = Folder(app.activeScript.path);
myFolder = myFolder.parent + '/Scripts Panel/';
var menuItem1Handler = function( /*onInvoke*/ ){
  app.doScript(File(myFolder + 'MyTest1.jsx'));
var menuItem2Handler = function( /*onInvoke*/ ){
  app.doScript(File(myFolder + 'MyTest2.jsx'));
menuInstaller()
function menuInstaller() {
  var menuItem1T = "My Menu Item 1",
       menuItem2T = "My Menu Item 2",
       menuT = "MyTestMenu",
             subT = "Sub Menu",
       subs = app.menus.item("$ID/Main").submenus, sma, mnu;
  var refItem = app.menus.item("$ID/Main").submenus.item("$ID/&Layout");
  subMenu1 = app.scriptMenuActions.item(menuItem1T);
  if( subMenu1 == null ) {
          subMenu2 = app.scriptMenuActions.add(menuItem1T);
  subMenu2 = app.scriptMenuActions.item(menuItem2T);
  if( subMenu2 == null ) {
          subMenu2 = app.scriptMenuActions.add(menuItem2T);
  subMenu2.eventListeners.add("onInvoke", menuItem2Handler);
  mnu = subs.item(menuT);
  if( mnu == null ) {
            mnu = subs.add(menuT, LocationOptions.after, refItem);
  mnu.menuItems.add(subMenu1);
  mnu.menuSeparators.add();
  subsSubs = app.menus.item( '$ID/Main' ).submenus.item( menuT ).submenus;
  mnuSubMenu = subsSubs.item( subT );
  if( mnuSubMenu == null ) {
          mnuSubMenu = subsSubs.add( subT);
  mnu.menuItems.add(subMenu2);

Answer 1

Hey, Marc: I'm going to be sort of blunt. Your code is hard for most people to read because it uses Javascript idioms they are entirely unfamiliar with, which don't make a lot of sense to people not really familiar with the language. And that's what most people here are. Let's take a walk through it:
(function(/*obj|undefined*/HOST)
The comment itself is confusing. Actually, it's even confusing to me.
    HOST || (HOST=$.global);
Tbe || idiom is confusing. Most people don't know what it means offhand.
    // Prevent the current (startup) script from being uselessly rerun
    if( HOST[$.engineName] )
        alert( "This script is automatically executed at startup. You shouldn't run it manually." );
Well, this isn't confusing, but I think it's bad. One of the important things to do is to test what happens when the menus already exist, and that's easiest to do by rerunning the script.
    var MENU_NAME = "My Test Menu",
All caps for a function-local variable? Even using all caps for a globally scoped variable (Crockford) is confusing, but for a function-scope variable? That confuses me!
        FEATURES = [
            { caption: "My Menu Item 1", fileName: 'File-One.jsx', subName: "" },
Use of Objects is justified here, but they are probably confusing.
        FEATURE_LOCATION_PATH = (function()
Anonymous functions...definitely confusing! I'm also not sure what the point of this function heere is. Why not execute the code directly
on the next line?
            try{ f=app.activeScript; }
            catch(_){ f=File(_.fileName); }
Variables named "_"? Confusing!
And this is why anonymous functions are confusing! Not much to be done about it, but why use one where you don't need to. It's not like we're polluting the global namespace here.
    while( i-- )
Use of a while loop is a totally legitimate style choice, but I think it's typically less readable than a for loop. YMMV, of course!
        t = FEATURES[i];
I'm horribly guilty of this, but single-letter variable names are not the most readable.
            (t.action = app.scriptMenuActions.add( t.caption )).
                addEventListener('onInvoke', f);
More parentheses imply more mental gymnastics to understand. Breaking this into two lines,
with t.action=addEventListener... would help readability.
  var s,
        n = FEATURES.length,
        subs = {},
        sub = null;
Wait, a mid-function var block? Gasp! What's up with that? Crockford's right on this. One var statement and all at the top.
I am not sure why we're initializing sub to null -- what's wrong with the good old undefined? This probably doesn't qualify as confusing.
    for( i=0 ; i < n ; ++i )
Caching FEATURES.length in n is good for performance, but it probably doesn't matter here, and makes it more confusing to read. Not by much, but let's say half a confusion point. I would also say that "++i" is harder to read than "i++", maybe to the tune of 0.1 confusion-points, but maybe that's just me. YMMV Extremely.
        sub = (s=t.subName) ?
            ( subs[s] || (subs[s]=mnu.submenus.add( s, LO_END )) ) :
            mnu;
The ternary conditional operator, ?:, is pretty much always hard to read. And it's worse with short-circuit or-ing, ||, or three close-parens in rapid succession. Of course ?: tends to promote extra () as it almost always becomes ()?(): so...
And then it's worth re-emphasizing, basically nobody understands the anonymous function paradigm .
So there we have it, that's why I think your code is confusing to most readers.
(On the other hand Dan's final code ignores my recommendation and still has those abysmal ==null tests in there. What's up with that? )