guest271314 (2019-06-01T22:30:07.000Z)
guest271314 at gmail.com (2019-06-01T23:16:02.519Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URL``` (1 file) to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. The export code ("module") is dynamic. Each exported module entry (identifier) can be checked one at a time before proceeding, to ensure no "collision" at import. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pure-es6"; "how many" (the gist of the code) would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:59:38.666Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. The export code ("module") is dynamic. Each exported module entry (identifier) can be checked one at a time before proceeding, to ensure no "collision" at import. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pure-es6"; "how many" (the gist of the code) would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:57:31.942Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. The export code ("module") is dynamic. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pure-es6"; "how many" (the gist of the code) would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:49:36.384Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pure-es6"; "how many" (the gist of the code) would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:45:47.128Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pure-es6"; "how many" would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:44:28.822Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pre-es6"; "how many" would still be until memory runs out, if you were able to run the code at least 1000.
guest271314 at gmail.com (2019-06-01T22:43:28.916Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result besides loading N "async-modules" using "pre-es6"; "how many" would still be until memory runs out, at least 1000.
guest271314 at gmail.com (2019-06-01T22:39:27.612Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry and ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries at a list of module property identifiers (as strings) can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result. There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"?
guest271314 at gmail.com (2019-06-01T22:38:37.789Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry an ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There is more than one possible approach to achieve the presumptive requirement; that is still not clear to the exclusion of what is not the expected result. There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine code "suitability" for "production-use"? How is that procedure related to "how many async-modules can js-app practically load?"?
guest271314 at gmail.com (2019-06-01T22:35:11.113Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry an ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There is more than one possible approach to achieve the presumptive requirement, that is still not clear to the exclusion of what is not the expected result. There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. If by "bundle" is meant exporting multiple resources (sync or async) in a single JavaScript plain object, without "collision", that is what the code achieves. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine if code is "production-use" "suitable"? How is that procedure related to "how many async-modules can js-app practically load?"?
guest271314 at gmail.com (2019-06-01T22:33:08.768Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry an ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There is more than one possible approach to achieve the presumptive requirement, that is still not clear to the exclusion of what is not the expected result. There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine if code is "production-use" "suitable"? How is that procedure related to "how many async-modules can js-app practically load?"?
guest271314 at gmail.com (2019-06-01T22:32:30.329Z)
> your rollup solution is interesting, What is "rollup" referring to? > but i get an error when run in chrome (i changed to n=20 to prevent name-collision, but it still happens). The duplicate ("collision") entry an ```try..catch``` block is included in the code to demonstrate given an array of module names to be exported and imported as identifiers 1) duplicate entries can be filtered; 2) if a plain object is exported duplicate identifiers ("collision") is not possible as a JavaScript plain object does not have duplicate property names ("collision"); if there is an issue with identifiers in a module the cause would not be the number of async-modules loaded ("how many"), but the naming of the identifiers within the code, using or not using ```const``` or ```let```. As noted in comments within the code, you can set and check your own unique identifier names as strings that will be imported as module properties. Still not sure what the actual issue is? > don't completely understand how it works, Use an ```async``` function to fetch data, check for the described "collision" , create a ```data URI``` to be imported, optionally, append addition code to be executed within the ```<script type="module">```. > but not sure of suitability for production-use, because of its dynamic <script> tag generation. What is the issue with dynamic ```<script>``` tag generation? There is more than one possible approach to achieve the presumptive requirement, that is still not clear to the exclusion of what is not the expected result. There were no restrictions described at the OP and following messages other than other than > pure-es6 application with 20 es-modules rolled-up into one [production] bundle? The example code uses only JavaScript implementation shipped with the browser without any external, third-party libraries. What standard or definition are you relying for the meaning of the term "production-use"? What procedure are you using to determine if code is "production-use" "suitable"? How is that procedure related to "how many async-modules can js-app practically load?"?