bundler-inc.tsx

@@ -1,8 +1,13 @@
-import Bundler from "./mod.ts";
+import B from "./mod.ts";
 
-const results = await Bundler();
+const results = await B({
+    imports: {
+        "react": "https://esm.sh/preact@10.22.0/compat",
+        "react/": "https://esm.sh/preact@10.22.0/compat/"
+    }
+});
 
 for await(const file of results.outputFiles)
 {
-    console.log(file.text);
+    console.log(file.path);
 }

deep/deep.tsx

@@ -1,2 +0,0 @@
-import "../app.tsx";
-console.log("we deep!");

introspect.tsx

@@ -6,16 +6,14 @@ type JsonLike = JsonDeep
 
 type Configuration = {imports:JsonDeep, compilerOptions:JsonDeep};
 
-
+export const Root = new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString();
-/** A `file://` url version of Deno.cwd() */
-export const Root = new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString() + "/";
 export default async function HuntConfig()
 {
     let path:string, json:JsonLike|undefined;
 
     const loadJSON =async(inPath:string)=>{
         try{
-            const resp = await fetch(Root + inPath);
+            const resp = await fetch(Root + "/" + inPath);
             if(inPath.endsWith(".jsonc"))
             {
                 const text = await resp.text();

mod.ts

@@ -1,64 +1,65 @@
 import * as ESBuild from "https://deno.land/x/esbuild@v0.19.2/wasm.js";
 import * as Mapper from "https://esm.sh/esbuild-plugin-importmaps@1.0.0"; // https://github.com/andstellar/esbuild-plugin-importmaps
-import Introspect, {Root} from "./introspect.ts";
 
-
+export const Root = new URL(`file://${Deno.cwd().replaceAll("\\", "/")}`).toString()+"/";
-const prefix = "/_dot_importer_/";
+console.log("running at", Root);
 const resolvePlugin:ESBuild.Plugin = {
   name: "resolve-plugin",
   setup(build) {
-    build.onResolve({ filter: /^(\.\/|\.\.\/).*/ }, (args)=>
+    build.onResolve({ filter: /^\.\/.*$/ }, args => {
-    {
+      console.log("RESOLVE")
-      let resolveRoot = args.importer||Root;
+      console.log("in:", args)
-      if(resolveRoot.startsWith(prefix))
+      const path = new URL(args.path, Root).pathname
-      {
+      const output = {
-        resolveRoot = resolveRoot.substring(prefix.length);
+        path,
-      }
+        namespace: 'file',
-      const output:ESBuild.OnResolveResult = {
+      };
-        path:prefix + new URL(args.path, resolveRoot).href,
+      console.log("out:", output)
-        namespace:"http",
-      }
       return output;
     });
-    build.onLoad({ filter: /.*/, namespace:"http" }, async(args)=> {
+
-      const fetchPath = args.path.substring(prefix.length);
+    build.onLoad({ filter: /.*/, namespace:"file" }, async (args) => {
-      const result = await fetch(fetchPath);
+      console.log("LOAD")
-      const contents = await result.text();
+      console.log(args)
-      return { contents, loader: `tsx` };
+      let contents;
+      try
+      {
+        const result = await fetch("file://"+args.path);
+        contents = await result.text();
+      }
+      catch(e)
+      {
+        console.log("deno fs access error:", e)
+      }
+      
+      return {
+        contents,
+        loader: args.path.endsWith('.tsx') ? 'tsx' : 'default',
+      };
     });
   },
 };
 
-export type ImportMap = Parameters<typeof Mapper.importmapPlugin>[0];
+type ImportMap = Parameters<typeof Mapper.importmapPlugin>[0];
-export type BuildOptions = ESBuild.BuildOptions;
-export default async function(buildOptions={} as BuildOptions, importMap:ImportMap|false = false)
-{
-  if(importMap === false)
-  {
-    importMap = await Introspect() as ImportMap;
-  }
 
-  const configuration:ESBuild.BuildOptions = {
+  await ESBuild.initialize({ worker: false });
-    //entryPoints: ["./app.tsx"],
+  const result = await ESBuild.build({
-    entryPoints: ["entry"],
+    entryPoints: ["./app.tsx"],
-    //entryPoints: ["./deep/deep.tsx"],
-    //entryPoints: ["http://localhost:4507/deep/deep.tsx"],
     bundle: true,
     minify: true,
     format: "esm",
     jsx: "automatic",
     jsxImportSource: "react",
-    ...buildOptions,
+    plugins:[
-    plugins: [
       resolvePlugin,
-      Mapper.importmapPlugin(importMap) as ESBuild.Plugin,
+      Mapper.importmapPlugin({
-      ...buildOptions.plugins||[]
+        imports:{"react":"https://esm.sh/preact@10.22.0/compat"}
+      }) as ESBuild.Plugin
     ]
-  };
+  });
-  await ESBuild.initialize({ worker: false });
-  const result = await ESBuild.build(configuration);
   ESBuild.stop();
-  return result;
-}
 
-export { ESBuild };
+for(const item of result.outputFiles)
+{
+  console.log(item.text)
+}

other.tsx

@@ -1,3 +1,3 @@
-//import React from "react";
+import React from "react";
-//console.log(React.createElement("div", {}, "hey"));
+console.log(React.createElement("div", {}, "hey"));
 export default "TEST STRING";

serve.tsx

@@ -1,4 +1,9 @@
 import bundler from "./mod.ts";
+import Introspect, {Root} from "./introspect.tsx";
+
+const Config = await Introspect();
+
+console.log(Config.imports);
 
 const transpiled:Map<string, string> = new Map();
 
@@ -8,31 +13,18 @@ Deno.serve(async(req)=>{
     if(index > -1)
     {
         const ext = url.pathname.substring(index+1, index+3);
-
-        console.log(ext);
-        console.log(url.pathname);
-
         if(ext === "ts")
         {
-            const results = await bundler({
+            const results = await bundler({imports:Config.imports}, {
-                entryPoints:["."+url.pathname],
+                entryPoints:[Root+url.pathname],
                 outfile:"bundle.js",
                 entryNames: `[dir][name]`,
             });
             results.outputFiles?.forEach(output=>{
                 transpiled.set(output.path, output.text);
             })
-            return new Response(`
+            return new Response(results.outputFiles[0].text, {headers:{"content-type":"application/javascript"}});
-path: ${results.outputFiles[0].path}
-hash: ${results.outputFiles[0].hash}
-`, {headers:{"content-type":"application/javascript"}});
         }
-
-        if(ext == "js")
-        {
-            return new Response(transpiled.get(url.pathname)||"---", {headers:{"content-type":"application/javascript"}});
     }
-
+    return new Response(Root+url.pathname);
-    }
-    return new Response(url.pathname);
 });