init

deno.json

@@ -0,0 +1 @@
+{}

index.html

@@ -0,0 +1,11 @@
+<script type="module" src="test_receiver.mjs"></script>
+
+<script type="module">
+    import r1 from "./test_rand.mjs?1";
+    import r2 from "./test_rand.mjs?2";
+    import r3 from "./test_rand.mjs?3";
+    import r4 from "./test_rand.mjs?4";
+
+    console.log(r1, r2, r3, r4);
+
+</script>

junk/module_inspector.test.ts

@@ -0,0 +1,24 @@
+import * as Inspector from "./module_inspector.ts";
+
+Deno.test("check string parsing", ()=>{
+
+    const [local, global] = Inspector.Exports(`
+// export in comment
+/**
+ * 
+* export const TESTtt
+ * /
+const fakeexport =()=>{};
+const exportfake =()=>{};
+export * from "react";
+export{ thing1 as remapped, thing2}
+export{ thing1 as remapped, thing2} from 'React';
+export 
+export default function(){}
+export const func=()=>{};
+export let func=()=>{};
+`)
+
+    console.log(local, global);
+
+})

junk/module_inspector.ts

@@ -0,0 +1,139 @@
+
+type GlyphCheck = (inGlyph:string)=>boolean
+const isAlphaLike:GlyphCheck =(inGlyph:string)=>
+{
+    const inCode = inGlyph.charCodeAt(0);
+
+    if(inCode >= 97 && inCode <= 122)
+    {
+        return true;
+    }
+
+    if(inCode >= 65 && inCode <= 90)
+    {
+        return true;
+    }
+
+    return `$_.`.includes(inGlyph);
+}
+const isWhiteSpace:GlyphCheck =(inGlyph:string)=> `\n\r\t `.includes(inGlyph);
+const isQuote:GlyphCheck =(inGlyph:string)=>`"'\``.includes(inGlyph)
+const isNot =(inCheck:GlyphCheck)=> (inGlyph:string)=>!inCheck(inGlyph);
+const contiguous =(inText:string, inStart:number, inTest:GlyphCheck):number=>
+{
+    let ok = true;
+    let index = inStart;
+    let count = 0;
+    while(ok && count < inText.length)
+    {
+        count++;
+        ok = inTest(inText.charAt(index++));
+    }
+    return index-1;
+}
+
+const findNextExport =(inFile:string, inIndex=0, inLocal:Array<string>, inForeign:Array<string>)=>
+{
+    const pos = inFile.indexOf("export", inIndex);
+    if(pos !== -1)
+    {
+        if(!isAlphaLike(inFile.charAt(pos-1)) || !isAlphaLike(inFile.charAt(pos+6)))
+        {
+            
+            const nextCharInd = contiguous(inFile, pos+6, isWhiteSpace);
+            const nextChar = inFile[nextCharInd];
+
+            //console.log(inFile.substring(pos, nextCharInd+1), `>>${nextChar}<<`)
+
+            if(nextChar === "*")
+            {
+                const  firstQuoteInd = contiguous(inFile,   nextCharInd+1, isNot(isQuote) );
+                const secondQuoteInd = contiguous(inFile, firstQuoteInd+1, isNot(isQuote) );
+                //console.log("ASTERISK:", inFile.substring(pos, secondQuoteInd+1));
+                inForeign.push(inFile.substring(nextCharInd, secondQuoteInd+1));
+            }
+            else if(nextChar == "{")
+            {
+                const endBracketInd = contiguous(inFile, nextCharInd, (inGlyph:string)=>inGlyph!=="}");
+                const nextLetterInd = contiguous(inFile, endBracketInd+1, isWhiteSpace);
+                if(inFile.substring(nextLetterInd, nextLetterInd+4) == "from")
+                {
+                    const  firstQuoteInd = contiguous(inFile, nextLetterInd+4, isNot(isQuote) );
+                    const secondQuoteInd = contiguous(inFile, firstQuoteInd+1, isNot(isQuote) );
+                    //console.log(`BRACKET foreign: >>${inFile.substring(nextCharInd, secondQuoteInd+1)}<<`);
+                    inForeign.push(inFile.substring(nextCharInd, secondQuoteInd+1));
+                }
+                else
+                {
+                    const members = inFile.substring(nextCharInd+1, endBracketInd).replace(/\s/g, '');
+                    members.split(",").forEach(part=>
+                    {
+                        const renamed = part.split(" as ");
+                        inLocal.push(renamed[1] || renamed[0]);
+                    });
+                }
+                
+            }
+            else if(isAlphaLike(nextChar))
+            {
+                const keywordEndInd = contiguous(inFile, nextCharInd, isAlphaLike);
+                const keyword = inFile.substring(nextCharInd, keywordEndInd);
+                if(keyword === "default")
+                {
+                    inLocal.push(keyword);
+                    //console.log(`MEMBER: >>${keyword})}<<`);
+                }
+                else if(["const", "let", "var", "function", "class"].includes(keyword))
+                {
+                    const varStartInd = contiguous(inFile, keywordEndInd+1, isWhiteSpace);
+                    const varEndInd = contiguous(inFile, varStartInd+1, isAlphaLike);
+                    //console.log(`MEMBER: >>${inFile.substring(varStartInd, varEndInd)}<<`);
+                    inLocal.push(inFile.substring(varStartInd, varEndInd))
+                }
+            }
+        }
+
+        return pos + 7;
+    }
+    else
+    {
+        return false;
+    }
+};
+
+export const Exports =(inFile:string)=>
+{
+    let match = 0 as number|false;
+    let count = 0;
+    const local = [] as string[];
+    const foreign = [] as string[];
+    while(match !== false && count <200)
+    {
+        count++;
+        match = findNextExport(inFile, match, local, foreign);
+    }
+    return[local, foreign] as [local:string[], foreign:string[]];
+};
+
+export const FileExports =async(inURL:string|URL)=>
+{
+    const resp = await fetch(inURL);
+    const text = await resp.text();
+    return Exports(text);
+}
+
+//console.log(await FileExports(import.meta.resolve("./hmr-listen.tsx")));
+
+/*
+const [local, global] = Exports(`
+// export in comment
+export * from "react";
+const fakeexport =()=>{};
+export{ thing1 as remapped, thing2}
+export{ thing1 as remapped, thing2} from 'React';
+export 
+export const func=()=>{};
+`);
+
+console.log(local, global);
+*/

junk/server.tsx

@@ -0,0 +1,17 @@
+const Extension =(inPath:string)=>
+{
+    const posSlash = inPath.lastIndexOf("/");
+    const posDot = inPath.lastIndexOf(".");
+    return posDot > posSlash ? inPath.substring(posDot+1).toLowerCase() : false;
+};
+
+
+
+Deno.serve((r)=>{
+
+    const url = new URL(r.url);
+    const ext = Extension(url.pathname);
+    
+
+    return new Response();
+})

test_application.mjs

@@ -0,0 +1,11 @@
+import {changing} from "./test_changer.mjs";
+
+const area = document.createElement("pre");
+document.body.append(area);
+Render();
+
+export function Render()
+{
+    console.log("pulling changing", changing)
+    area.innerHTML = changing;
+}

test_changer.mjs

@@ -0,0 +1,14 @@
+export let changing = 2;
+
+const thisURL = new URL(import.meta.url)
+const thisFile = thisURL.pathname;
+if(!thisURL.search)
+{
+    setInterval(()=>{
+        import(thisFile+"?"+Math.random()).then(module=>{
+            
+            changing = module.changing;
+            console.log(changing);
+        })
+    }, 3000);
+}

test_rand.mjs

@@ -0,0 +1 @@
+export default Math.random();

test_receiver.mjs

@@ -0,0 +1,9 @@
+import * as App from "./test_application.mjs";
+
+const button = document.createElement("button");
+button.innerHTML = "Reload";
+button.addEventListener("click", ()=>
+{
+    App.Render();
+})
+document.body.append(button);