router started

example/deep/component.tsx

@@ -4,8 +4,13 @@ import * as Iso from "@eno/iso";
 export default ()=>
 {
     const [countGet, countSet] = React.useState(1);   
+
+    const [routeGet, routeSet] = Iso.Router.Consumer();
+
     return <div class="p-4 text-red-500">
         <Iso.Metas title="Component!"/>
+        Route is: {routeGet.Path.toString()}
+        <button className="p-4 bg-red-500 text-white" onClick={e=>{countSet(countGet+1); routeSet(["lol", "idk"], {count:countGet});}}>{countGet}</button>
         Component!!!
     </div>;
 };

example/deno.json

@@ -8,6 +8,7 @@
         "@eno/iso": "http://localhost:4507/lib/iso.tsx"
     },
     "tasks": {
+        "host": "deno run -A --unstable https://deno.land/std@0.181.0/http/file_server.ts",
         "dev": "deno run -A --unstable --reload=http://localhost:4507/ --no-lock --config=deno.json 'http://localhost:4507/server.tsx?reload=1'"
     }
 }

lib/iso.tsx

@@ -32,3 +32,47 @@ export const Metas =(props:{concatListed?:boolean; dropUnlisted?:boolean}&MetasI
 
     return null;
 }
+
+type RoutePath = Array<string>;
+type RouteParams = Record<string, string>;
+type RouteState = {URL:URL, Path:string[]};
+type RouteContext = [Route:RouteState, Update:(inPath?:RoutePath, inParams?:RouteParams)=>void];
+type RouteProps = {children:typeof React.Children, url?:URL };
+export const Router = {
+    Path(url:URL)
+    {
+        return url.pathname.substring(1, url.pathname.endsWith("/") ? url.pathname.length-1 : url.pathname.length).split("/");
+    },
+    Context:React.createContext([{URL:new URL("https://original.route/"), Path:[]}, ()=>{}] as RouteContext),
+    Provider(props:RouteProps)
+    {
+        const url = props.url || new URL(document.location.href);
+        const path = Router.Path(url);
+
+        const [routeGet, routeSet] = React.useState({URL:url, Path:path} as RouteState);
+        //const routeUpdate:RouteContext[1] =(inURL:URL)=>routeSet({URL:inURL, Path:Router.Path(inURL)});
+        const routeUpdate:RouteContext[1] =(inPath?:RoutePath, inParams?:RouteParams)=>
+        {
+            const clone = new URL(routeGet.URL.href);
+            inPath && (clone.pathname = `/${inPath.join("/")}`);
+            inParams && (clone.search = new URLSearchParams(inParams).toString());
+            routeSet({
+                URL:clone,
+                Path: inPath ? inPath : routeGet.Path
+            });
+        };
+
+        React.useEffect(()=>history.pushState({Path:routeGet.Path, Params:routeGet.URL.search}, "", routeGet.URL), [routeGet.URL.href]);
+        React.useEffect(()=>{
+            window.addEventListener("popstate", ()=>routeUpdate());
+        }, []);
+
+        return <Router.Context.Provider value={[routeGet, routeUpdate]}>
+            {props.children}
+        </Router.Context.Provider>;
+    },
+    Consumer()
+    {
+        return React.useContext(Router.Context);
+    }
+};

server.tsx

@@ -3,9 +3,16 @@ import * as MIME from "https://deno.land/std@0.180.0/media_types/mod.ts";
 import { debounce } from "https://deno.land/std@0.151.0/async/debounce.ts";
 import SSR from "https://esm.sh/v113/preact-render-to-string@6.0.2";
 import * as Twind from "https://esm.sh/@twind/core@1.1.3";
-import React, {JSX, createElement as h} from "react";
+import React from "react";
 import * as Iso from "@eno/iso";
 
+let hosted = import.meta.resolve("./");
+const Path = {
+    Hosted:hosted.substring(0, hosted.length-1),
+    Active:`file://${Deno.cwd().replaceAll("\\", "/")}`
+};
+console.log(Path);
+
 const Transpiled = new Map();
 const Transpileable =(inFilePath:string):boolean=>
 {
@@ -33,19 +40,6 @@ const Transpile =async(inCode:string, inKey:string):Promise<string>=>
     return transpile.code;
 };
 type Transpiler = (inPath:string, inKey:string, inCheck?:boolean)=>Promise<string>;
-const TranspileFS:Transpiler =async(inPath, inKey, inCheck)=>
-{
-    if(inCheck)
-    {
-        const cached = Transpiled.get(inKey);
-        if(cached)
-        {
-            return cached;
-        }
-    }
-    const body = await Deno.readTextFile(inPath);
-    return Transpile(body, inKey);
-};
 const TranspileURL:Transpiler =async(inPath, inKey, inCheck)=>
 {
     if(inCheck)
@@ -56,8 +50,7 @@ const TranspileURL:Transpiler =async(inPath, inKey, inCheck)=>
             return cached;
         }
     }
-    const path = import.meta.resolve(`.${inPath}`);
-    let body = await fetch(path);
+    let body = await fetch(inPath);
     let text = await body.text();
     return Transpile(text, inKey);
 };
@@ -68,8 +61,8 @@ type ImportMap = {imports?:Record<string, string>, importMap?:string};
 let ImportObject:ImportMap = {};
 try
 {
-    const confDeno = await Deno.readTextFile(Deno.cwd()+"/deno.json");
-    const confDenoParsed:ImportMap = JSON.parse(confDeno);
+    const confDeno = await fetch(`${Path.Active}/deno.json`);
+    const confDenoParsed:ImportMap = await confDeno.json();
     if(confDenoParsed.importMap)
     {
         try
@@ -147,10 +140,9 @@ catch(e)
 Deno.serve({ port: Deno.args[0]||3000 }, async(_req:Request) =>
 {
     const url:URL = new URL(_req.url);
-    const fsPath = Deno.cwd()+url.pathname;
     const pathParts = url.pathname.substring(1, url.pathname.endsWith("/") ? url.pathname.length-1 : url.pathname.length).split("/");
-    const pathLast = pathParts[pathParts.length-1];
-    const pathExt:string|undefined = pathLast.split(".")[1];
+    const pathLast = pathParts.at(-1);
+    const pathExt:string|undefined = pathLast?.split(".")[1];
 
     console.log(pathParts, pathLast, pathExt);
 
@@ -194,12 +186,11 @@ Deno.serve({ port: Deno.args[0]||3000 }, async(_req:Request) =>
             type = `application/javascript`;
             if(isLib)
             {
-                body = await TranspileURL(url.pathname, url.pathname, true);
+                body = await TranspileURL(Path.Hosted+url.pathname, url.pathname, true);
             }
             else if(!url.searchParams.get("reload"))
             {
-                const path = `file://${Deno.cwd().replaceAll("\\", "/")+url.pathname}`;
-                const imp = await import(path);
+                const imp = await import(Path.Active+url.pathname);
                 const members = [];
                 for( const key in imp ) { members.push(key); }
                 body =
@@ -218,26 +209,19 @@ FileListen("${url.pathname}", reloadHandler);`;
             }
             else
             {
-                body = await TranspileFS(fsPath, url.pathname, true);
+                body = await TranspileURL(Path.Active+url.pathname, url.pathname, true);
             }
         }
         // serve static media
         else if( pathExt )
         {
             type = MIME.typeByExtension(pathExt) || "text/html";
-            if(isLib)
-            {
-                const _fetch = await fetch(import.meta.resolve(`.${url.pathname}`));
+            const _fetch = await fetch((isLib ? Path.Hosted : Path.Active)+url.pathname);
             body = await _fetch.text();
         }
         else
         {
-                body = await Deno.readFile(fsPath);
-            }
-        }
-        else
-        {
-            const results = Twind.extract(SSR(<App/>), TwindInst);
+            const results = Twind.extract(SSR(<Iso.Router.Provider url={url}><App/></Iso.Router.Provider>), TwindInst);
 
             type = `text/html`;
             body = `<!doctype html>
@@ -256,8 +240,9 @@ FileListen("${url.pathname}", reloadHandler);`;
             import {render, createElement as H} from "react";
             import * as Twind from "https://esm.sh/@twind/core@1.1.3";
             import {default as App, CSS} from "@eno/app";
+            import {Router} from "@eno/iso";
             Twind.install(CSS);
-            render(H(()=>H(App)), document.querySelector("#app"));
+            render( H(Router.Provider, null, H(App)), document.querySelector("#app"));
         </script>
     </body>
 </html>`;
@@ -289,7 +274,7 @@ const ProcessFiles =debounce(async()=>
 
         if(action != "remove")
         {
-            await TranspileFS(path, key, false);
+            await TranspileURL(Path.Active+key, key, false);
             console.log(`  ...cached "${key}"`);
             SocketsBroadcast(key);
         }