In

<inject_sources>
js=js1
js=js2
</inject_sources>

js=js1 loads js1 and js=js2 loads js2. No difference, just an example of 
loading more than one dependency in the same inject tag.

I don’t think supporting both inject_html and inject_js is much simpler than 
parsing the above syntax and generating the required js/html, and it would be 
simpler in my opinion for the user, and for the fw developer.

I didn’t figure out why in release dialogPolyfill causes a failure on startup. 
Interestingly, there’s no such failure in debug mode, even if I remove the 
inject_script.

It maybe possible to dynamically load App.js but I didn’t investigate that.

I think having a simple syntax and avoiding making the user think too much when 
using a 3rd party lib is important. I tried to address that too in my proposal.

From: Alex Harui<mailto:aha...@adobe.com.INVALID>
Sent: Tuesday, May 19, 2020 6:06 PM
To: dev@royale.apache.org<mailto:dev@royale.apache.org>
Subject: Re: Script Loading Order (Continuing Heads-Up thread from Users)

I don’t think I understand the proposal.  What is the difference between the 
two "js" definitions?

I think we could support both inject_html and inject_script and require 
inject_script for modules, so framework usage would have to have both 
inject_html and inject_script equivalents and report an error if compiling a 
module and inject_html is found but not inject_script.

Did we ever figure out what code would fail if DialogPolyFill wasn't loaded 
before App.js?  I'm hoping we're not doing all of this work for an edge case 
with a simple workaround.

Is another option to dynamically load App.js?

-Alex

On 5/19/20, 12:22 AM, "Yishay Weiss" <yishayj...@hotmail.com> wrote:

    I propose to change the syntax to

    <inject_sources>
                    
js=https://nam04.safelinks.protection.outlook.com/?url=http%3A%2F%2Fjs1.js%2F&amp;data=02%7C01%7Caharui%40adobe.com%7Cb1259c69852b4f53b37f08d7fbc56837%7Cfa7b1b5a7b34438794aed2c178decee1%7C0%7C0%7C637254697587653756&amp;sdata=NpxmSDXB8KCIBR4dpCV5PsZneS5nTjgyZ%2FO3AZSkgFc%3D&amp;reserved=0
                    
js=https://nam04.safelinks.protection.outlook.com/?url=http%3A%2F%2Fjs2.js%2F&amp;data=02%7C01%7Caharui%40adobe.com%7Cb1259c69852b4f53b37f08d7fbc56837%7Cfa7b1b5a7b34438794aed2c178decee1%7C0%7C0%7C637254697587653756&amp;sdata=Wp%2BG2aFd%2BRcN5FruFAZEDT36PK0zfRCDEDolggrhQBM%3D&amp;reserved=0
                    
css=https://nam04.safelinks.protection.outlook.com/?url=http%3A%2F%2Fcss1.js%2F&amp;data=02%7C01%7Caharui%40adobe.com%7Cb1259c69852b4f53b37f08d7fbc56837%7Cfa7b1b5a7b34438794aed2c178decee1%7C0%7C0%7C637254697587653756&amp;sdata=xLOMEC4Fcxwbv1JBa8WU2%2Fgx%2BAhAbF1B731IxNZIspI%3D&amp;reserved=0
    <inject_sources>

    If it’s in the main app the compiler will parse this and inject html, same 
way it did before. Injected html is ensured to load serially, so it should load 
before App.js.

    If it’s in a module the compiler will parse this and inject a script to the 
__deps file we create for modules, similar to what’s being done now. It may be 
that we’ll need to add to the script some mechanism to ensure serial loading, 
similar to what gcl does.

    I can explore this when I have more time, probably next week, or someone 
else is welcome to fix this differently.

    Thanks.



    From: Alex Harui<mailto:aha...@adobe.com.INVALID>
    Sent: Monday, May 18, 2020 7:53 PM
    To: dev@royale.apache.org<mailto:dev@royale.apache.org>
    Subject: Re: Script Loading Order (Continuing Heads-Up thread from Users)

    Ah, ok.  I thought that closure was injecting the main app's script block 
so the dynamic script would be in front of it but it makes sense that wouldn't 
happen at release time.

    IIRC, we control the launch of the app.  I thought there is one more script 
somewhere that calls app.start() that is generated by the compiler.  IMO, that 
script can be altered to wait for scripts to load.

    HTH,
    -Alex


    On 5/18/20, 8:44 AM, "Yishay Weiss" <yishayj...@hotmail.com> wrote:

        Unless I missed something that’s what it’s doing right now after my 
fix. I’ll try to explain the scenario as I see it (no modules).

        Suppose we have an app that compiles to the following html.

        <html>
                        <head>
                                        <script type="text/javascript">
                                                        var script = 
document.createElement("script");
                                                        
script.setAttribute("src", "hljs.min.js");
                                                        
document.head.appendChild(script);
                                        </script>
                                        <script type=”text/JavaScript” 
src=”App.js”></script>
                        </head>
                        <body></body>
        </html>

        After the first script element is loaded, the dom will look like:

        <html>
                        <head>
                                        <script type="text/javascript">
                                                        var script = 
document.createElement("script");
                                                        
script.setAttribute("src", "hljs.min.js");
                                                        
document.head.appendChild(script);
                                        </script>
                                        <script type=”text/JavaScript” 
src=”hljs.min.js”></script>
                                        <script type=”text/JavaScript” 
src=”App.js”></script>
                        </head>
                        <body></body>
        </html>

        However, App.js will still be loaded before hljs.min.js because it was 
not created dynamically. App.js will fail because it depends on hljs.

        From: Alex Harui<mailto:aha...@adobe.com.INVALID>
        Sent: Monday, May 18, 2020 6:21 PM
        To: dev@royale.apache.org<mailto:dev@royale.apache.org>
        Subject: Re: Script Loading Order (Continuing Heads-Up thread from 
Users)

        I don't think we have to inject these scripts into the main .js file.  
The compiler knows when it is compiling the main app or a module.  When 
compiling the main app, it should inject the script in the HEAD of the html 
wrapper.  For modules, it can inject the script into a separate file.  The 
ModuleLoader already loads extra files before loading the module.  It can load 
one more file.

        Of course, I could be wrong...
        -Alex

        On 5/18/20, 7:38 AM, "Yishay Weiss" <yishayj...@hotmail.com> wrote:

            From what I’ve read [1] scripts injected dynamically will always 
load after static script elements. So I don’t think there’s a good way to 
ensure the proper order in run-time unless we do something like 
99a8c8356573ff16b668f2d39a447355c673fee3 , but that’s verbose and working with 
libs should be simple.

            Any ideas?

            [1] 
https://nam04.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.html5rocks.com%2Fen%2Ftutorials%2Fspeed%2Fscript-loading%2F%23disqus_thread&amp;data=02%7C01%7Caharui%40adobe.com%7Cb1259c69852b4f53b37f08d7fbc56837%7Cfa7b1b5a7b34438794aed2c178decee1%7C0%7C0%7C637254697587653756&amp;sdata=KKBA2grWRQsVSj6Ykq2Sx3UJEPFo8yD7VuK4KF2FaRY%3D&amp;reserved=0

            From: Alex Harui<mailto:aha...@adobe.com.INVALID>
            Sent: Monday, May 18, 2020 8:03 AM
            To: dev@royale.apache.org<mailto:dev@royale.apache.org>


            Subject: Re: Script Loading Order (Continuing Heads-Up thread from 
Users)

            Every time I look, closure seems to change how it works.  It looks 
like they are using callbacks and UIDs.  I assume they can't use await or 
Promise because of IE support.  I haven't looked at the code you generate, but 
might have to do something similar, IOW, wait for the callback or known value 
before continuing.

            I think that if we create the script during the running of another 
script that we have to find a way to wait for that created script.

            It might help to know what kind of initialization code needed the 
definition so early.  One alternative is that such code needs to be responsible 
for waiting.

            Most of our Application classes have a wait mechanism.  We could 
leverage that, but that's also pretty late.

            It could be that for Applications we generate the script in the 
head, and for modules we generate a separate script that is preloaded.

            HTH,
            -Alex

            On 5/17/20, 9:03 AM, "Yishay Weiss" <yishayj...@hotmail.com> wrote:


                >Is the script tag from inject_script going before or after the 
script tag for the application (should be before, >IMO)?

                It’s going before but the network shows it’s loaded after.

                >Make sure the script tag has the same settings as the script 
tags google closure uses in js-debug.  I think they set some options so the 
scripts load in order.

                I see type being specified in the gcl script elements, while 
inject ones don’t. I suppose it’s worth seeing if that makes a difference, 
though I couldn’t find evidence for that on the web.








Reply via email to