outpost relay mode started

boot-server.tsx

@@ -1,15 +0,0 @@
-import "./run-serve.tsx";
-
-Deno.args.forEach(arg=>
-{
-    if(arg.startsWith("--"))
-    {
-        const kvp = arg.substring(2).split("=");
-        Deno.env.set(kvp[0], kvp[1] || "true");
-    }
-});
-
-if(Deno.env.get("dev"))
-{
-  await import("./run-local.tsx");
-}

boot.deno.tsx

@@ -0,0 +1,6 @@
+import "./run-serve.tsx";
+
+if(Deno.env.get("dev"))
+{
+  await import("./run-local.tsx");
+}

example/app.tsx

@@ -1,4 +1,4 @@
-import "@able/boot-server.tsx";
+import "http://localhost:1234/boot.tsx";
 import React from "react";
 
 const CTXString = React.createContext("lol");
@@ -38,7 +38,7 @@ export default ()=>
     return <CTXString.Provider value="intradestink">
         <div class="my-4 font-sans">
             <h1 class="font-black text-xl text-red-500">Title????</h1>
-            <h2>subtitle!</h2>
+            <h2 class="p-4">subtitle!!!!</h2>
             <p>
                 <button onClick={e=>Dispatch(1)}>{Store.name}|{Store.age}?</button>
             </p>

example/deno.json

@@ -3,11 +3,11 @@
     "imports":
     {
         "react":"https://esm.sh/preact@10.15.1/compat",
-        "@able/":"http://localhost:4507/"
+        "@able/":"http://localhost:8000/"
     },
     "tasks":
     {
-        "local": "deno run -A --no-lock --reload=http://localhost:4507 app.tsx --dev",
-        "serve": "deno run -A --no-lock --reload=http://localhost:4507 app.tsx"
+        "local": "deno run -A --no-lock --reload app.tsx --dev",
+        "serve": "deno run -A --no-lock --reload app.tsx"
     }
 }

example/dyn-test.tsx

@@ -0,0 +1,15 @@
+
+import * as Util from "@able/";
+import * as React from "react";
+import {createElement} from "react/client";
+
+import('react').then((module) => {
+  console.log(module);
+});
+
+
+function unimport(n:number)
+{
+  return n;
+}
+unimport(123)

hmr-listen.tsx

@@ -13,7 +13,7 @@ Socket.addEventListener('message', async(event:{data:string})=>
 {
     // When a file changes, dynamically re-import it to get the updated members
     // send the updated members to any listeners for that file
-    const reImport = await import(event.data+"?reload="+Math.random());
+    const reImport = await import(document.location.origin+event.data+"?reload="+Math.random());
     FileListeners.get(event.data)?.forEach(reExport=>reExport(reImport));
     HMR.update();
 });

iso-menu.tsx

@@ -0,0 +1,224 @@
+import React from "react";
+
+type StateArgs = {done?:boolean, open?:boolean};
+type StateObj = {done:boolean, open:boolean};
+type StateBinding = [state:StateObj, update:(args:StateArgs)=>void];
+
+const CTX = React.createContext([{done:true, open:false}, (args)=>{}] as StateBinding);
+
+export const Group =(props:{children:React.JSX.Element|React.JSX.Element[]})=>
+{
+    const [stateGet, stateSet] = React.useState({done:true, open:false} as StateObj);
+    return <CTX.Provider value={[stateGet, (args:StateArgs)=> stateSet({...stateGet, ...args})]}>{props.children}</CTX.Provider>;
+};
+
+export const Menu =(props:{children:React.JSX.Element|React.JSX.Element[]})=>
+{
+    const [stateGet, stateSet] = React.useContext(CTX);
+    const refElement:React.MutableRefObject<HTMLElement|null> = React.useRef( null );
+    const refControl:React.MutableRefObject<CollapseControls|null> = React.useRef( null );
+    const refInitial:React.MutableRefObject<boolean> = React.useRef(true);
+
+    type MenuClassStates = {Keep:string, Open:string, Shut:string, Move:string, Exit:string};
+    const base = `relative transition-all border(8 black) overflow-hidden`;
+    const Classes:MenuClassStates =
+    {
+      Shut: `${base} h-0    top-0  w-1/2   duration-300`,
+      Open: `${base} h-auto top-8  w-full  duration-700`,
+      lol: `${base} h-auto top-36 bg-yellow-500  w-2/3  duration-700`,
+    };
+    const Window = window as {TwindInst?:(c:string)=>string};
+    if(Window.TwindInst)
+    {
+      for(let stateName in Classes)
+      {
+        Classes[stateName as keyof MenuClassStates] = Window.TwindInst(Classes[stateName as keyof MenuClassStates]);
+      }
+    }
+
+    React.useEffect(()=>
+    {
+      refControl.current = refElement.current && Collapser(refElement.current, stateGet.open ? "Open" : "Shut", Classes);
+    }
+    , []);
+    React.useEffect(()=>
+    {
+      (!refInitial.current && refControl.current) && refControl.current(stateGet.open ? "Open" : "Shut", ()=>stateSet({done:true}));
+      refInitial.current = false;
+    }
+    , [stateGet.open]);
+
+    useAway(refElement, (e)=>stateSet({open:false, done:false}) );
+
+    return <div ref={refElement as React.Ref<HTMLDivElement>} class={Classes.Shut}>
+      { (!stateGet.open && stateGet.done) ? null : props.children}
+    </div>;
+};
+
+export const Button =()=>
+{
+    const [stateGet, stateSet] = React.useContext(CTX);
+    return <>
+        <p>{JSON.stringify(stateGet)}</p>
+        <button class="px-10 py-2 bg-red-500 text-white" onClick={e=>stateSet({open:true,  done:false})}>Open</button>
+        <button class="px-10 py-2 bg-red-500 text-white" onClick={e=>stateSet({open:false, done:false})}>Close</button>
+    </>;
+};
+
+type Handler = (e:MouseEvent)=>void
+const Refs:Map<HTMLElement, React.Ref<Handler>> = new Map();
+function isHighest(inElement:HTMLElement, inSelection:HTMLElement[])
+{
+  let currentNode = inElement;
+  while (currentNode != document.body)
+  {
+    currentNode = currentNode.parentNode as HTMLElement;
+    if(currentNode.hasAttribute("data-use-away") && inSelection.includes(currentNode))
+    {
+      return false;
+    }    
+  }
+  return true;
+}
+window.innerWidth && document.addEventListener("click", e=>
+{
+  const path = e.composedPath();
+  const away:HTMLElement[] = [];
+
+  Refs.forEach( (handlerRef, element)=>
+  {
+    if(!path.includes(element) && handlerRef.current)
+    {
+      away.push(element);
+    }
+  });
+
+  away.forEach((element)=>
+  {
+    if(isHighest(element, away))
+    {
+      const handler = Refs.get(element);
+      handler?.current && handler.current(e);
+    }
+  });
+
+}
+, true);
+const useAway =(inRef:React.Ref<HTMLElement>, handleAway:Handler)=>
+{
+  const refHandler:React.MutableRefObject<Handler> = React.useRef(handleAway);
+  refHandler.current = handleAway;
+
+  React.useEffect(()=>
+  {
+    if(inRef.current)
+    {
+      inRef.current.setAttribute("data-use-away", "0");
+      Refs.set(inRef.current, refHandler);      
+    }
+    return ()=> inRef.current && Refs.delete(inRef.current);
+  }
+  , []);
+};
+
+type StyleSize = [classes:string, width:number, height:number];
+type StylePack = Record<string, string>;
+type StyleCalc = Record<string, StyleSize>;
+const StyleCalc =(inElement:HTMLElement, inClasses:StylePack)=>
+{
+  const initialStyle = inElement.getAttribute("style")||"";
+  const initialClass = inElement.getAttribute("class")||"";
+  const output = {} as StyleCalc;
+
+  inElement.setAttribute("style", `transition: none;`);
+  Object.entries(inClasses).forEach(([key, value])=>
+  {
+    inElement.setAttribute("class", value);
+    output[key] =  [value, inElement.offsetWidth, inElement.offsetHeight];
+  });
+  inElement.setAttribute("class", initialClass);
+  inElement.offsetHeight; // this has be be exactly here
+  inElement.setAttribute("style", initialStyle);
+
+  return output;
+};
+
+type DoneCallback =(inState:string)=>void;
+export type CollapseControls =(inOpen?:string, inDone?:DoneCallback)=>void;
+export function Collapser(inElement:HTMLElement, initialState:string, library:Record<string, string>)
+{
+    let userDone:DoneCallback = (openState) => {};
+    let userMode = initialState;
+    let frameRequest = 0;
+    let inTransition = false;
+    let measurements:StyleCalc;
+    const transitions:Set<string> = new Set();
+
+    const run = (inEvent:TransitionEvent)=> (inEvent.target == inElement) && transitions.add(inEvent.propertyName);
+    const end = (inEvent:TransitionEvent)=>
+    {
+      if (inEvent.target == inElement)
+      {
+        transitions.delete(inEvent.propertyName);
+        if(transitions.size === 0)
+        {
+          measurements = StyleCalc(inElement, library);
+          const [, w, h] = measurements[userMode];
+          if(inElement.offsetHeight != h || inElement.offsetWidth != w)
+          {
+            anim(userMode, userDone);
+          }
+          else
+          {
+            inElement.setAttribute("style", "");
+            inTransition = false;
+            userDone(userMode);   
+          }
+        }
+      }
+    };
+    const anim = function(inState:string, inDone)
+    {
+      cancelAnimationFrame(frameRequest);
+
+      if(arguments.length)
+      {
+        if(!library[inState]){ return; }
+
+        userDone = inDone|| ((m)=>{}) as DoneCallback;
+        userMode = inState;
+
+        if(!inTransition)
+        {
+          measurements = StyleCalc(inElement, library);
+        }
+
+        if(measurements)
+        {
+          const [classes, width, height] = measurements[inState] as StyleSize;
+          const oldWidth = inElement.offsetWidth;
+          const oldHeight = inElement.offsetHeight;
+          inElement.style.width  = oldWidth  + "px";
+          inElement.style.height = oldHeight + "px";
+          inTransition = true;
+
+          frameRequest = requestAnimationFrame(()=>
+          {
+            inElement.style.height = height + "px";
+            inElement.style.width = width + "px";
+            inElement.className = classes;
+          });
+        }
+      }
+      else
+      {
+        inElement.removeEventListener("transitionrun", run);
+        inElement.removeEventListener("transitionend", end);
+      }
+    } as CollapseControls;
+
+    inElement.addEventListener("transitionend", end);
+    inElement.addEventListener("transitionrun", run);
+
+    return anim;
+} 

run-local.tsx

@@ -21,7 +21,7 @@ Configure({
     Remap: (inImports, inConfig)=>
     {
         inImports["react-original"] = inImports["react"];
-        inImports["react"] = `${inConfig.Spoof}/hmr-react.tsx`;
+        inImports["react"] = import.meta.resolve(`./hmr-react.tsx`);
         return inImports;
     },
     async Serve(inReq, inURL, inExt, inMap, inConfig)
@@ -33,7 +33,7 @@ Configure({
             for( const key in imp ) { members.push(key); }
 
             const code =`
-import {FileListen} from "${inConfig.Spoof}/hmr-listen.tsx";
+import {FileListen} from "${import.meta.resolve(`./hmr-listen.tsx`)}";
 import * as Import from "${inURL.pathname}?reload=0";
 ${ members.map(m=>`let proxy_${m} = Import.${m}; export { proxy_${m} as ${m} };`).join("\n") }
 FileListen("${inURL.pathname}", (updatedModule)=>

run-serve.tsx

@@ -1,9 +1,28 @@
 import * as MIME from "https://deno.land/std@0.180.0/media_types/mod.ts";
-import * as HTTP from "https://deno.land/std@0.177.0/http/server.ts";
 import * as SWCW from "https://esm.sh/@swc/wasm-web@1.3.62";
 
+
+Deno.args.forEach(arg=>
+{
+    if(arg.startsWith("--"))
+    {
+        const kvp = arg.substring(2).split("=");
+        Deno.env.set(kvp[0], kvp[1] || "true");
+    }
+});
+
+const urls = {
+    Cwd: new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString(),
+    App: Deno.mainModule,
+    Mod: import.meta.url,
+    Look: import.meta.resolve("./boot.tsx")
+};
+
+console.log(JSON.stringify(urls, null, " "));
+
 type DenoConfig = {imports:Record<string, string>};
 const ImportMap:DenoConfig = {imports:{}};
+let ImportMapOriginal = {};
 const ImportMapReload =async()=>
 {
     let json:DenoConfig;
@@ -14,6 +33,7 @@ const ImportMapReload =async()=>
         json = await resp.json();
         if(!json?.imports)
         { throw new Error("imports not specified in deno.json") }
+        ImportMapOriginal = json;
     }
     catch(e)
     {
@@ -29,12 +49,14 @@ const ImportMapReload =async()=>
         }
     });
 
+    /*
     const mapKey = (Configuration.Spoof.startsWith("/") ? Configuration.Spoof.substring(1) : Configuration.Spoof)+"/";
     if(!json.imports[mapKey])
     {
         console.log(`"${mapKey}" specifier not defined in import map`);
     }
     json.imports[mapKey] = Configuration.Spoof+"/";
+    */
 
     if(!json.imports["react"])
     {
@@ -55,7 +77,7 @@ let Configuration:Configuration =
     Allow: "*",
     Reset: "/clear-cache",
     Spoof: "/@able",
-    Serve(inReq, inURL, inExt, inMap, inConfig){},
+    async Serve(inReq, inURL, inExt, inMap, inConfig){},
     Remap: (inImports, inConfig)=>
     {
         const reactURL = inImports["react"];
@@ -81,8 +103,8 @@ let Configuration:Configuration =
                     <div id="app"></div>
                     <script type="importmap">${JSON.stringify(inMap)}</script>
                     <script type="module">
-                        import Mount from "${inConfig.Spoof}/boot-browser.tsx";
-                        Mount("#app", "${parts[1]??"/app.tsx"}");
+                        import Mount from "${import.meta.resolve("./boot.tsx")}";
+                        Mount("#app", document.location.origin+"${parts[1]??"/app.tsx"}");
                     </script>
                 </body>
             </html>`, {status:200, headers:{"content-type":"text/html"}});
@@ -127,7 +149,85 @@ export const Transpile =
         ImportMapReload();
         return size;
     },
-    Fetch: async function(inPath:string, inKey:string, inCheckCache=true)
+    /**
+     * Converts dynamic module imports in to static, also can resolve paths with an import map
+     */
+    async Patch(inPath:string, inKey:string, inMap?:DenoConfig)
+    {
+        const check = this.Cache.get(inKey);
+        if(check)
+        {
+            return check;
+        }
+
+        let file, text;
+        try
+        {
+            file = await fetch(inPath);
+            text = await file.text();
+        }
+        catch(e)
+        {
+            return false;
+        }
+
+        const remap = inMap ? (inPath:string)=>
+        {
+            const match = inMap.imports[inPath];
+            if(match)
+            {
+                return match;
+            }
+            else if(inPath.includes("/"))
+            {
+                let bestKey = "";
+                let bestLength = 0;
+                Object.keys(inMap.imports).forEach((key, i, arr)=>
+                {
+                    if(key.endsWith("/") && inPath.startsWith(key) && key.length > bestLength)
+                    {
+                        bestKey = key;
+                        bestLength = bestLength;
+                    }
+                });
+                if(bestKey)
+                {
+                    return inMap.imports[bestKey]+inPath.substring(bestKey.length);
+                }
+            }
+            return inPath;
+        }
+        : (inPath:string)=>inPath;
+        let match, regex;
+        let convertedBody = text;
+
+        // remap static imports
+        regex = /from\s+(['"`])(.*?)\1/g;
+        while ((match = regex.exec(text)))
+        {
+          const importStatement = match[0];
+          const importPath = match[2];
+          convertedBody = convertedBody.replace(importStatement, `from "${remap(importPath)}"`);
+        }
+
+        // convert dynamic imports into static (to work around deno deploy)
+        const staticImports = [];
+        regex = /(?<![\w.])import\(([^)]+)(?!import\b)\)/g;
+        while ((match = regex.exec(text)))
+        {
+            const importStatement = match[0];
+            const importPath = remap(match[1].substring(1, match[1].length-1));
+            const moduleName:string = `_dyn_${staticImports.length}`;
+
+            staticImports.push(`import ${moduleName} from ${importPath};`);
+            convertedBody = convertedBody.replace(importStatement, `Promise.resolve(${moduleName})`);
+        }
+        convertedBody = staticImports.join("\n") + convertedBody;
+        
+        inKey && this.Cache.set(inKey, convertedBody);
+        return convertedBody;
+    },
+    async Fetch(inPath:string, inKey:string, inCheckCache=true)
     {
         const check = this.Cache.get(inPath);
         if(check && inCheckCache)
@@ -153,6 +253,19 @@ export const Transpile =
     }
 };
 
+
+export const ExtensionPrefix =(string:string, suffix:string)=>
+{
+    const lastDotIndex = string.lastIndexOf(".");
+    if (lastDotIndex === -1) {
+        return string;
+    }
+    
+    const prefix = string.substring(0, lastDotIndex);
+    const suffixString = string.substring(lastDotIndex + 1);
+    return prefix + "." + suffix + "." + suffixString;
+};
+
 export const Extension =(inPath:string)=>
 {
     const posSlash = inPath.lastIndexOf("/");
@@ -168,7 +281,7 @@ export const Configure =(config:ConfigurationArgs)=>
 
 await ImportMapReload();
 await SWCW.default();
-HTTP.serve(async(req: Request)=>
+const server = Deno.serve({port:parseInt(Deno.env.get("port")||"8000")}, async(req: Request)=>
 {
     const url:URL = new URL(req.url);
     const ext = Extension(url.pathname);
@@ -192,19 +305,30 @@ HTTP.serve(async(req: Request)=>
     {
         let code;
         let path;
-        if(url.pathname.startsWith(Configuration.Spoof+"/"))
+        let file;
+        if( req.headers.get("user-agent")?.startsWith("Deno") || url.searchParams.has("deno") )
         {
-            const clipRoot = import.meta.url.substring(0, import.meta.url.lastIndexOf("/"));
-            const clipPath = url.pathname.substring(url.pathname.indexOf("/", 1));
-            if(clipPath.startsWith("/boot-"))
+            try
             {
-                path = clipRoot+"/boot-browser.tsx";
+                path = Configuration.Proxy + ExtensionPrefix(url.pathname, "deno");
+                console.log("looking for", path);
+                file = await fetch(path) as Response;
+                if(file.ok)
+                {
+                    code = await file.text();
                 }
                 else
                 {
-                path = clipRoot + clipPath;
+                    throw new Error("404")
+                }
+            }
+            catch(e)
+            {
+                path = Configuration.Proxy + url.pathname;
+                console.log("falling back to", path);
+                file = await fetch(path);
+                code = await file.text();
             }
-            code = await Transpile.Fetch(path, url.pathname, true);
         }
         else
         {

things.md

@@ -0,0 +1,56 @@
+# Outpost
+
+## Deno Deploy
+```
+accept:  */*
+accept-encoding:  gzip, br
+accept-language:  *
+cdn-loop:  deno;s=deno;d=ah40t9m8n54g
+host:  bad-goat-66.deno.dev
+user-agent:  Deno/1.34.1
+```
+
+## Deno
+```
+accept:  */*
+accept-encoding:  gzip, br
+accept-language:  *
+host:  bad-goat-66.deno.dev
+user-agent:  Deno/1.34.3
+```
+
+## Edge
+```
+accept:  text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
+accept-encoding:  gzip, deflate, br
+accept-language:  en-US,en;q=0.9
+host:  bad-goat-66.deno.dev
+referer:  https://dash.deno.com/
+sec-ch-ua:  "Microsoft Edge";v="117", "Not;A=Brand";v="8", "Chromium";v="117"
+sec-ch-ua-mobile:  ?0
+sec-ch-ua-platform:  "Windows"
+sec-fetch-dest:  iframe
+sec-fetch-mode:  navigate
+sec-fetch-site:  cross-site
+upgrade-insecure-requests:  1
+user-agent:  Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36 Edg/117.0.0.0
+```
+
+## Firefox
+```
+accept:  text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
+accept-encoding:  gzip, deflate, br
+accept-language:  en-US,en;q=0.5
+host:  bad-goat-66.deno.dev
+sec-fetch-dest:  document
+sec-fetch-mode:  navigate
+sec-fetch-site:  cross-site
+te:  trailers
+upgrade-insecure-requests:  1
+user-agent:  Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0
+```
+
+When a requet comes in:
+- if its for a transpile-able document:
+  - if its a request from deno:
+    -