How does live object creation and partial teardown management work in javascript?

Question

What I would like to do is load javascript to create a library of methods in an object and wait until the object is used for the first time before it is actually defined or compiled. I would like to build references to this object before it is actually fully defined. When I call a method on this object for the first time before the methods on the object are ever defined (meaning the object doesn't actually have methods) I would like to define the object and then call the method. Is there a way to do this using standard syntax such as "MyLibrary.sayHello()" if "sayHello()" is not yet defined on the object. I imagine it would look like this:

var independentVar = "noCommitments";
var MyLibrary = function(user_ini){
    //MyLibrary.init looks like
    // (function(ini){
    //     var a = ini; 
    //     return function(){
    //         //Notice the method sayHello defines when called,
    //         // and does not return a reference
    //         return {
    //             b:a,c:"c",sayHello:function(z){return "Hello"+a+z}
    //         }
    //     }
    // })(user_ini);
    var d1 = myRequire("MyLibrary.init");
    return {
        **handleAll : function(){ this = d1(); this.("**calledMethod")}
    }
};

var greeting = MyLibrary.sayHello();

alert(greeting);

This is only pseudo-code. If I add a method to cleanup I can then return that object to the uninitialized state of "{**handleAll:function(){/noContext/}}". My application/library has a stub and a link this way and can be used immediately from an undefined state, when building modules this can be useful in order to lower the number of references to a utility, say a post has a menu of functions and those functions are shared by by all posts, -- with a mechanism such as is described here only the "active post"/"post in focus" will reference the utility. It moreless give the ability to activate and de-activate modules. The special part is the modules are already warmed up, they are ready to call functions even though they do not reference them yet, it is similar to live binding but allows the whole user interface to already be defined with functions already stubbed out with the exact name they will have when they are usable. A control mechanism for defaults and debounce is easily found in this model for me.

My question is: Is this type of scripting possible natively or will I have to use some form of compilation like for TypeScript, CoffeeScript or others. I understand it is possible if I pass the method I would like to call as a parameter to a singleton factory. I ultimately would like whole applications that are able to gracefully degrade unused functionality without polluting the code.

What I mean by pollution:

var LibDef = (
function(){
    return {
        callUndefined:function(methodName){
            var returnVal = {}
        }
    }
})()

var MySingltonLibrary = moduleSinglton.getLibrary("MyLibrary", Lib);
var greeting = MySingltonLibrary.callUndefined("sayHello");
//
// Please use your imagination to consider the complexity in the singlton

Answer 1

The best way that will allow you to tear down an object releasing any space its functions and members consume on the heap and maintain a single reference, that will allow the object to rebuild itself or just rebuild the function that is called is like this - (A very simple model, you may like to use arrays and gradually tear down nested objects internally):

var twentySecondObj(function(window,document){
    var base_obj = undefined;
    var externalAPI = undefined;
    setTimeout(function(){
        base_obj = undefined;
    },20000);
    return function(){
        base_obj = (function(base_obj){
            if(base_obj === undefined){
                return {
                    property1:"This is property1",
                    property2:"This is property2"
                }
            }
        })();
        externalAPI = (function(){
            if(externalAPI === undefined){
                return {
                    property1:base_obj.property1,
                    property2:base_obj.property2
                }
            }
        })();
        return externalAPI;
    }
})(window,document);

console.log(twentySecondObj().property1);

On an additional note, you can use getters and setters to observe access to properties and can internally present a facade of both functions and properties which reference a build method like the one above, this way it looks like you are accessing a legit member of the object. There are no options I can think of that will allow you to intercept when attempt to set a new property on an object like: myObj.fooProperty = "foo", and buildup that property into a custom object with a getter and setter, if you have a custom type that needs to be set, then you will have to know it's implimentation details to set it, or call a function passing in the property name and value, or use a method similar to what is shown above.

Here is a link to the proposal for adding weak references to javascript: https://ponyfoo.com/articles/weakref weak-references would alter how this looks, however would not address everything mentioned in this question. Remapping an object when a property is added via some type of deep observer will allow new property members to be enhanced at the time they are set, this would require that the observer ran synchrounously when the property was set, or once the set is complete, the very next statement must be a call to update the object. I will keep posted here for any advances I see that will make the "default handler function" available within javascript in the future.

WeakRef can absolutely be used for recording and handling object usage. I would really like to move object management into webworkers and service workers so they can be maintained through all web endpoints on the domain and do not require to reload across requests. Web frameworks would need to have modified handle to offload all dom changes and updates to worker, essentially a single hook that handles message passing for all hooks. Modload, now must include a message handle name and have task priority meta data so it is properly placed in the least busy or least active worker (slow worker and fast worker) this helps to create an api that can offload to cloud functions, this shpuld give us ability to do more AI, lookups and work offline that is currently handled for most apps in the cloud where more processing power is, and in this way we can gracefully augment local processing with cloud functions only when local resources, or completion times are degraded below acceptable speeds, or above acceptable power policy.

https://v8.dev/features/weak-references