wurzel 0.0.4 → 0.0.5

package/dist/bin/wurzel.js

@@ -13,5 +13,5 @@ app.use("/", wurzel({ express, baseFolder: rootFolder }));
 const port = 8080;
 
 app.listen(port, () => {
-    console.log(`listening on :${port}`);
+  console.log(`listening on :${port}`);
 });

package/dist/lib/index.d.ts

@@ -1,5 +1,6 @@
+import type Express from "express";
 declare const expressRouter: ({ express, baseFolder, fileEndings, maxAnalyzeCacheSize, maxTranspileCacheSize, }: {
-    express: any;
+    express: typeof Express;
     baseFolder: string;
     fileEndings?: string[];
     maxAnalyzeCacheSize?: number;

package/dist/lib/index.js

@@ -3,245 +3,242 @@ import { readFile } from "node:fs/promises";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
 import { resolve as resolveImport } from "import-meta-resolve";
-// @ts-ignore
+// @ts-expect-error missing types
 import { transpileCode } from "commentscript";
 import { LRUCache } from "lru-cache";
-
-// @ts-ignore
 /*import type { ICodeAnalyzeResult } from "es6-debug-server";*/
+/*import type Express from "express";*/
 
 const md5 = ({ content }/*: { content: string }*/) => {
-    return createHash("md5").update(content).digest("hex");
+  return createHash("md5").update(content).digest("hex");
 };
 
 /*interface ITranspileErrorResult {
-    error: Error;
-    transpiled?: undefined;
+  error: Error;
+  transpiled?: undefined;
 }*/;
 
 /*interface ITranspileSuccessResult {
-    error: undefined;
-    transpiled: string;
+  error: undefined;
+  transpiled: string;
 }*/;
 
 /*type TTranspileResult = ITranspileErrorResult | ITranspileSuccessResult;*/
 
 const expressRouter = ({
-    express,
-    baseFolder,
-    fileEndings = [".js", ".ts"],
+  express,
+  baseFolder,
+  fileEndings = [".js", ".ts"],
 
-    maxAnalyzeCacheSize = 1 * 1024 * 1024,
-    maxTranspileCacheSize = 64 * 1024 * 1024,
+  maxAnalyzeCacheSize = 1 * 1024 * 1024,
+  maxTranspileCacheSize = 64 * 1024 * 1024,
 }/*: {
-    express: any,
-    baseFolder: string,
-    fileEndings?: string[],
+  express: typeof Express,
+  baseFolder: string,
+  fileEndings?: string[],
 
-    maxAnalyzeCacheSize?: number,
-    maxTranspileCacheSize?: number,
+  maxAnalyzeCacheSize?: number,
+  maxTranspileCacheSize?: number,
 }*/) => {
 
-    const router = express.Router();
+  const router = express.Router();
+
+  const transpileCache = new LRUCache/*<string, string>*/({
+    maxSize: maxTranspileCacheSize,
+    sizeCalculation: (value, key) => {
+      return key.length + value.length;
+    }
+  });
+
+  const analyzeCache = new LRUCache/*<string, ICodeAnalyzeResult>*/({
+    maxSize: maxAnalyzeCacheSize,
+    sizeCalculation: (value, key) => {
+      return key.length + JSON.stringify(value).length;
+    }
+  });
+
+  // eslint-disable-next-line complexity
+  const maybeTranspile = async ({ filePath, code }/*: { filePath: string, code: string }*/)/*: Promise<TTranspileResult>*/ => {
+    if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
+      return {
+        error: undefined,
+        transpiled: code
+      };
+    }
+
+    const hash = md5({ content: code });
+
+    const cached = transpileCache.get(hash);
+    if (cached !== undefined) {
+      return {
+        error: undefined,
+        transpiled: cached
+      };
+    }
+
+    let transpiled/*: string | undefined*/ = undefined;
+
+    try {
+      const result = await transpileCode({ code });
+      transpiled = result.transpiledCode;
+    } catch (ex) {
+      return {
+        error: ex/* as Error*/,
+      };
+    }
+
+    if (transpiled === undefined) {
+      throw Error("BUG: transpiled code is undefined");
+    }
+
+    transpileCache.set(hash, transpiled);
+
+    return {
+      error: undefined,
+      transpiled
+    };
+  };
 
-    const transpileCache = new LRUCache/*<string, string>*/({
-        maxSize: maxTranspileCacheSize,
-        sizeCalculation: (value, key) => {
-            return key.length + value.length;
-        }
-    });
+  const server = createServer({
 
-    const analyzeCache = new LRUCache/*<string, ICodeAnalyzeResult>*/({
-        maxSize: maxAnalyzeCacheSize,
-        sizeCalculation: (value, key) => {
-            return key.length + JSON.stringify(value).length;
-        }
-    });
+    scriptRootFolder: baseFolder,
+
+    tryReadScriptAsString: async ({ filePath }) => {
 
-    const maybeTranspile = async ({ filePath, code }/*: { filePath: string, code: string }*/)/*: Promise<TTranspileResult>*/ => {
+      const { error: readError, content } = await readFile(filePath, "utf8").then((fileContent) => {
+        return { error: undefined, content: fileContent };
+      }, (err/*: NodeJS.ErrnoException*/) => {
+        return { error: err, content: undefined };
+      });
 
-        if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
-            return {
-                error: undefined,
-                transpiled: code
-            };
+      if (readError !== undefined) {
+        if (readError.code === "ENOENT") {
+          return {
+            error: {
+              code: ETryReadErrorCode.FILE_NOT_FOUND,
+              message: readError.message,
+            }
+          };
         }
 
-        const hash = md5({ content: code });
+        return {
+          error: {
+            code: ETryReadErrorCode.IO_ERROR,
+            message: readError.message,
+          }
+        };
+      }
 
-        const cached = transpileCache.get(hash);
-        if (cached !== undefined) {
-            return {
-                error: undefined,
-                transpiled: cached
-            };
-        }
+      const { error: transpileError, transpiled } = await maybeTranspile({
+        filePath,
+        code: content
+      });
 
-        let transpiled/*: string | undefined*/ = undefined;
+      if (transpileError !== undefined) {
+        console.error(transpileError);
 
-        try {
-            const result = await transpileCode({ code });
-            transpiled = result.transpiledCode;
-        } catch (ex) {
-            return {
-                error: ex/* as Error*/,
-            };
-        }
+        return {
+          error: {
+            code: ETryReadErrorCode.IO_ERROR,
+            message: transpileError.message,
+          }
+        };
+      }
 
-        if (transpiled === undefined) {
-            throw Error("BUG: transpiled code is undefined");
-        }
+      return {
+        error: undefined,
+        content: transpiled
+      };
+    },
 
-        transpileCache.set(hash, transpiled);
+    // cache code analysis
+    analyzeCode: ({ code }) => {
+      const hash = md5({ content: code });
 
+      const cached = analyzeCache.get(hash);
+      if (cached !== undefined) {
         return {
-            error: undefined,
-            transpiled
+          error: undefined,
+          result: cached
         };
-    };
+      }
 
-    const server = createServer({
-
-        scriptRootFolder: baseFolder,
-
-        tryReadScriptAsString: async ({ filePath }) => {
-
-            const { error: readError, content } = await readFile(filePath, "utf8").then((content) => {
-                return { error: undefined, content };
-            }, (err/*: NodeJS.ErrnoException*/) => {
-                return { error: err, content: undefined };
-            });
-
-            if (readError !== undefined) {
-                if (readError.code === "ENOENT") {
-                    return {
-                        error: {
-                            code: ETryReadErrorCode.FILE_NOT_FOUND,
-                            message: readError.message,
-                        }
-                    };
-                }
-
-                return {
-                    error: {
-                        code: ETryReadErrorCode.IO_ERROR,
-                        message: readError.message,
-                    }
-                };
-            }
-
-            const { error: transpileError, transpiled } = await maybeTranspile({
-                filePath,
-                code: content
-            });
+      const analyzeResult = defaultCodeAnalyzer({ code });
+      if (analyzeResult.error !== undefined) {
+        return {
+          error: analyzeResult.error
+        };
+      }
 
-            if (transpileError !== undefined) {
-                console.error(transpileError);
+      analyzeCache.set(hash, analyzeResult.result);
+      return analyzeResult;
+    },
 
-                return {
-                    error: {
-                        code: ETryReadErrorCode.IO_ERROR,
-                        message: transpileError.message,
-                    }
-                };
-            }
+    resolveImportPath: async ({ importer, specifier }) => {
+      const parentUrl = pathToFileURL(importer);
+      let resolvedUrl/*: string | undefined*/ = undefined;
 
-            return {
-                error: undefined,
-                content: transpiled
-            };
-        },
+      try {
+        resolvedUrl = resolveImport(specifier, parentUrl.toString());
+      } catch (error) {
+        return {
+          error: error/* as Error*/
+        };
+      }
 
-        // cache code analysis
-        analyzeCode: ({ code }) => {
-            const hash = md5({ content: code });
+      const resolvedPath = fileURLToPath(resolvedUrl);
+      return {
+        error: undefined,
+        filePath: resolvedPath
+      };
+    },
+  });
 
-            const cached = analyzeCache.get(hash);
-            if (cached !== undefined) {
-                return {
-                    error: undefined,
-                    result: cached
-                };
-            }
+  router.use((req, res, next) => {
 
-            const analyzeResult = defaultCodeAnalyzer({ code });
-            if (analyzeResult.error !== undefined) {
-                return {
-                    error: analyzeResult.error
-                };
-            }
+    if (req.method === "HEAD") {
+      throw Error("HEAD not supported yet");
+    }
 
-            analyzeCache.set(hash, analyzeResult.result);
-            return analyzeResult;
-        },
+    const isScript = fileEndings.some((ending) => req.url.endsWith(ending));
+    if (isScript) {
 
-        resolveImportPath: async ({ importer, specifier }) => {
-            const parentUrl = pathToFileURL(importer);
-            let resolvedUrl/*: string | undefined*/ = undefined;
+      server.handleRequest({
+        uri: req.url,
 
-            try {
-                resolvedUrl = resolveImport(specifier, parentUrl.toString());
-            }
-            catch (error) {
-                return {
-                    error: error/* as Error*/
-                };
-            }
+        handleRedirect: ({ uri }) => {
+          const redirectLocation = `${req.baseUrl}${uri}`;
+          res.redirect(redirectLocation);
+        },
 
-            const resolvedPath = fileURLToPath(resolvedUrl);
-            return {
-                error: undefined,
-                filePath: resolvedPath
-            };
+        handleContent: ({ contentType, content }) => {
+          res.writeHead(200, {
+            "Content-Type": contentType
+          });
+          res.end(content);
         },
-    });
 
-    // @ts-ignore
-    router.use((req, res, next) => {
+        handleFileNotFound: () => {
+          res.status(404).end("not found");
+        },
 
-        if (req.method === "HEAD") {
-            throw Error("HEAD not supported yet");
+        handleInternalError: ({ error }) => {
+          console.error(error);
+          res.status(500).end("internal server error");
         }
+      });
 
-        const isScript = fileEndings.some((ending) => req.url.endsWith(ending));
-        if (isScript) {
-
-            server.handleRequest({
-                uri: req.url,
-
-                handleRedirect: ({ uri }) => {
-                    const redirectLocation = `${req.baseUrl}${uri}`;
-                    res.redirect(redirectLocation);
-                },
-
-                handleContent: ({ contentType, content }) => {
-                    res.writeHead(200, {
-                        "Content-Type": contentType
-                    });
-                    res.end(content);
-                },
-
-                handleFileNotFound: () => {
-                    res.status(404).end("not found");
-                },
-
-                handleInternalError: ({ error }) => {
-                    console.error(error);
-                    res.status(500).end("internal server error");
-                }
-            });
-
-            return;
-        }
+      return;
+    }
 
-        next();
-    });
+    next();
+  });
 
-    router.use(express.static(baseFolder));
+  router.use(express.static(baseFolder));
 
-    return router;
+  return router;
 };
 
 export {
-    expressRouter,
+  expressRouter,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wurzel",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "dist"
@@ -15,14 +15,18 @@
     "lru-cache": "^10.2.1"
   },
   "devDependencies": {
+    "@eslint/js": "^9.7.0",
     "@types/express": "^4.17.21",
     "@types/node": "^20.12.7",
-    "deno-node": "^0.0.4"
+    "deno-node": "^0.0.5",
+    "typescript-eslint": "^7.16.1"
   },
   "bin": {
     "wurzel": "dist/bin/wurzel.js"
   },
   "scripts": {
-    "build": "rm -rf dist/ && deno-node-build --root . --out dist/ --entry lib/index.ts --entry bin/wurzel.ts"
+    "build": "rm -rf dist/ && deno-node-build --root . --out dist/ --entry lib/index.ts --entry bin/wurzel.ts",
+    "lint": "eslint .",
+    "test": "true"
   }
 }