fix: e2e/test works!

Author: yowainwright

src/config.ts

@@ -11,12 +11,11 @@ import { ImportMap } from "@jspm/import-map";
  *
  * ******************************************************
  */
-export const rootUrl = import.meta.url;
-export const root = fileURLToPath(new URL(".", rootUrl));
+export const root = fileURLToPath(`file://${process.cwd()}`);
 export const cacheMap = new Map();
 export const nodeImportMapPath = join(root, "node.importmap");
 export const cache = join(root, ".cache");
 export const map = existsSync(nodeImportMapPath)
   ? JSON.parse(readFileSync(nodeImportMapPath, { encoding: "utf8" }))
   : {};
-export const importMap = new ImportMap({ rootUrl, map });
+export const importMap = new ImportMap({ rootUrl: import.meta.url, map });

src/constants.ts

@@ -1,4 +1,5 @@
 export const NO_CACHE_MAP_DEFINED =
   "No parentURL provided. No cachePath was defined. Couldn't get cachePath from cacheMap.";
 export const ALL_CACHE_MAP_REQUIREMENTS_MUST_BE_DEFINED = "All cacheMap requirements must be defined.";
-export const IS_DEBUGGING = Boolean(process.env.DEBUG) || false;
+// export const IS_DEBUGGING = Boolean(process.env.DEBUG) || false;
+export const IS_DEBUGGING = true;

src/loader.ts

@@ -1,11 +1,11 @@
-import { cacheMap, nodeImportMapPath } from "src/config";
+import { cacheMap, nodeImportMapPath } from "./config";
 import {
-  isNodeOrFileProtocol,
+  checkIfNodeOrFileProtocol,
   resolveNodeModuleCachePath,
   resolveModulePath,
   resolveParsedModulePath,
-} from "src/utils";
-import { Context, NextResolve } from "src/types";
+} from "./utils";
+import { Context, NextResolve } from "./types";
 
 /**
  * ******************************************************
@@ -33,8 +33,10 @@ import { Context, NextResolve } from "src/types";
  */
 export const resolve = async (specifier: string, { parentURL }: Context, nextResolve: NextResolve) => {
   if (!parentURL || !nodeImportMapPath) return nextResolve(specifier);
-  const modulePath = resolveModulePath(specifier, cacheMap.get(parentURL) || parentURL);
-  if (isNodeOrFileProtocol(modulePath)) return nextResolve(specifier);
+  const cacheMapPath = cacheMap.get(parentURL) || parentURL;
+  const modulePath = resolveModulePath(specifier, cacheMapPath);
+  const isNodeOrFileProtocol = checkIfNodeOrFileProtocol(modulePath);
+  if (isNodeOrFileProtocol) return nextResolve(specifier);
   const nodeModuleCachePath = await resolveNodeModuleCachePath(modulePath);
   if (!nodeModuleCachePath) return nextResolve(specifier);
   cacheMap.set(`file://${nodeModuleCachePath}`, modulePath);

src/logger.ts

@@ -9,6 +9,5 @@ export const logger = ({ file, isLogging = false }: LoggerOptions) => ({
   error: (msg: string, ...args: unknown[]) => {
     if (args) console.error(`jspm:[${file}]: ${msg}`, ...args);
     else console.error(`jspm:[${file}]: ${msg}`);
-  },
-  setLogger: (isLogging = false) => logger({ file, isLogging }),
+  }
 });

src/parser.ts

@@ -1,9 +1,10 @@
 import { existsSync, writeFileSync } from "node:fs";
 import fetch from "node-fetch";
-import { ensureDirSync } from "src/utils";
+import { ensureFileSync } from "src/utils";
+import { IS_DEBUGGING } from "src/constants";
 import { logger } from "src/logger";
 
-const log = logger({ file: "utils" });
+const log = logger({ file: "parser", isLogging: IS_DEBUGGING });
 
 /**
  * parseNodeModuleCachePath
@@ -13,12 +14,13 @@ const log = logger({ file: "utils" });
  * @returns {string}
  */
 export const parseNodeModuleCachePath = async (modulePath: string, cachePath: string) => {
+  log.debug('parseNodeModuleCachePath', cachePath, modulePath)
+  if (existsSync(cachePath)) return cachePath;
   try {
-    if (existsSync(cachePath)) return cachePath;
     const resp = await fetch(modulePath);
     if (!resp.ok) throw Error(`404: Module not found: ${modulePath}`);
     const code = await resp.text();
-    ensureDirSync(cachePath);
+    ensureFileSync(cachePath);
     writeFileSync(cachePath, code);
     return cachePath;
   } catch (err) {

src/utils.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseUrlPkg } from "@jspm/generator";
 import { parseNodeModuleCachePath } from "src/parser";
@@ -17,8 +17,7 @@ import { logger } from "src/logger";
  * ******************************************************
  */
 
-const log = logger({ file: "loader" });
-log.setLogger(IS_DEBUGGING);
+const log = logger({ file: "loader", isLogging: IS_DEBUGGING });
 
 export const ensureDirSync = (dirPath: string) => {
   if (existsSync(dirPath)) return;
@@ -27,7 +26,17 @@ export const ensureDirSync = (dirPath: string) => {
   mkdirSync(dirPath);
 };
 
-export const isNodeOrFileProtocol = (modulePath: string) => {
+export const ensureFileSync = (path: string) => {
+  const dirPath = dirname(path);
+  if (!existsSync(dirPath)) ensureDirSync(dirPath);
+  try {
+    writeFileSync(path, '', { flag: 'wx' });
+  } catch {
+    log.error(`ensureDirSync: Failed in creating ${path}`)
+  }
+}
+
+export const checkIfNodeOrFileProtocol = (modulePath: string) => {
   const { protocol = "" } = new URL(modulePath);
   const isNode = protocol === "node:";
   const isFile = protocol === "file:";
@@ -47,7 +56,7 @@ export const resolveNodeModuleCachePath = async (modulePath: string) => {
     const version = moduleMetadata?.pkg?.version;
     const moduleFile = modulePath.split("/").reverse()[0] || "";
     const nodeModuleCachePath = join(cache, `${name}@${version}`, moduleFile);
-    log.debug("resolveNodeModuleCachePath:", { name, version, nodeModuleCachePath });
+    log.debug("resolveNodeModuleCachePath:", { moduleMetadata, name, version, nodeModuleCachePath });
     return nodeModuleCachePath;
   } catch (err) {
     log.error("resolveNodeModuleCachePath:", err);

tests/e2e/test.js

@@ -1,14 +1,10 @@
 import * as TeleportProjectGeneratorPreact from "@teleporthq/teleport-project-generator-preact";
 import * as TeleportProjectGeneratorReact from "@teleporthq/teleport-project-generator-react";
 import * as TeleportTypes from "@teleporthq/teleport-types";
-import * as chalk from "chalk";
-import * as express from "express";
-import * as morgan from "morgan";
 import * as react from "react";
-import * as reactDom from "react-dom";
 import * as reactRouter from "react-router";
 import * as reactRouterDom from "react-router-dom";
 
 // Write main module code here, or as a separate file with a "src" attribute on the module script.
-console.log(TeleportProjectGeneratorPreact, TeleportProjectGeneratorReact, TeleportTypes, chalk, express, morgan, react, reactDom, reactRouter, reactRouterDom);
-console.log(chalk.default.green("Hello......."));
+console.log(TeleportProjectGeneratorPreact, TeleportProjectGeneratorReact, TeleportTypes, react, reactRouter, reactRouterDom);
+console.log("Hello.......");