@jsenv/core 36.1.1 → 36.1.2

package/src/plugins/transpilation/js_module_fallback/client/s.js

@@ -1,449 +0,0 @@
-/*
- * This file is a modified version of https://github.com/systemjs/systemjs/blob/main/dist/s.js
- * with the following changes:
- *
- * - Code can use aync/await, const, etc because this file is compiled (see dist/s.js)
- * - Can use document.currentScript because we don't support IE
- * - auto import inline System.register
- * - auto import first System.register in web workers
- * - queing events in web workers
- * - no support for importmap because jsenv don't need it
- */
-
-(function () {
-  /* eslint-env browser */
-
-  const loadRegistry = Object.create(null);
-  const registerRegistry = Object.create(null);
-  let inlineScriptCount = 0;
-  const System = {};
-
-  const hasDocument = typeof document === "object";
-  const envGlobal = self;
-  const isWorker =
-    !hasDocument &&
-    typeof envGlobal.WorkerGlobalScope === "function" &&
-    envGlobal instanceof envGlobal.WorkerGlobalScope;
-  const isServiceWorker = isWorker && typeof self.skipWaiting === "function";
-  envGlobal.System = System;
-
-  let baseUrl = envGlobal.location.href.split("#")[0].split("?")[0];
-  const lastSlashIndex = baseUrl.lastIndexOf("/");
-  if (lastSlashIndex !== -1) {
-    baseUrl = baseUrl.slice(0, lastSlashIndex + 1);
-  }
-
-  const resolveUrl = (specifier, baseUrl) => new URL(specifier, baseUrl).href;
-
-  if (hasDocument) {
-    const baseElement = document.querySelector("base[href]");
-    if (baseElement) {
-      baseUrl = baseElement.href;
-    }
-    System.register = (deps, declare) => {
-      if (!document.currentScript) {
-        throw new Error(
-          "unexpected call to System.register (document.currentScript is undefined)",
-        );
-      }
-      if (document.currentScript.__s__) {
-        registerRegistry[document.currentScript.src] = [deps, declare];
-        return null;
-      }
-      const url =
-        document.currentScript.src ||
-        `${window.location.href}__inline_script__${++inlineScriptCount}`;
-      registerRegistry[url] = [deps, declare];
-      return _import(url);
-    };
-    System.instantiate = (url) => {
-      const script = createScript(url);
-      return new Promise(function (resolve, reject) {
-        let lastWindowErrorUrl;
-        let lastWindowError;
-        const windowErrorCallback = (event) => {
-          lastWindowErrorUrl = event.filename;
-          lastWindowError = event.error;
-        };
-        window.addEventListener("error", windowErrorCallback);
-        script.addEventListener("error", () => {
-          window.removeEventListener("error", windowErrorCallback);
-          reject(`An error occured while loading url with <script> for ${url}`);
-        });
-        script.addEventListener("load", () => {
-          window.removeEventListener("error", windowErrorCallback);
-          document.head.removeChild(script);
-          // Note that if an error occurs that isn't caught by this if statement,
-          // that getRegister will return null and a "did not instantiate" error will be thrown.
-          if (lastWindowErrorUrl === url) {
-            reject(lastWindowError);
-          } else {
-            resolve();
-          }
-        });
-        document.head.appendChild(script);
-      });
-    };
-    const createScript = (url) => {
-      const script = document.createElement("script");
-      script.async = true;
-      // Only add cross origin for actual cross origin
-      // this is because Safari triggers for all
-      // - https://bugs.webkit.org/show_bug.cgi?id=171566
-      if (url.indexOf(`${self.location.origin}/`)) {
-        script.crossOrigin = "anonymous";
-      }
-      script.__s__ = true;
-      script.src = url;
-      return script;
-    };
-  }
-  if (isWorker) {
-    /*
-     * SystemJs loads X files before executing the worker/service worker main file
-     * It mean events dispatched during this phase could be missed
-     * A warning like the one below is displayed in chrome devtools:
-     * "Event handler of 'install' event must be added on the initial evaluation of worker script"
-     * To fix that code below listen for these events early and redispatch them later
-     * once the worker file is executed (the listeners are installed)
-     */
-    const firstImportCallbacks = [];
-    if (isServiceWorker) {
-      // for service worker there is more events to listen
-      // and, to get rid of the warning, we override self.addEventListener
-      const eventsToCatch = ["message", "install", "activate", "fetch"];
-      const eventCallbackProxies = {};
-      const firstImportPromise = new Promise((resolve) => {
-        firstImportCallbacks.push(resolve);
-      });
-      eventsToCatch.forEach((eventName) => {
-        const eventsToDispatch = [];
-        const eventCallback = (event) => {
-          const eventCallbackProxy = eventCallbackProxies[event.type];
-          if (eventCallbackProxy) {
-            eventCallbackProxy(event);
-          } else {
-            eventsToDispatch.push(event);
-            event.waitUntil(firstImportPromise);
-          }
-        };
-        self.addEventListener(eventName, eventCallback);
-        firstImportCallbacks.push(() => {
-          if (eventsToDispatch.length) {
-            const eventCallbackProxy =
-              eventCallbackProxies[eventsToDispatch[0].type];
-            if (eventCallbackProxy) {
-              eventsToDispatch.forEach((event) => {
-                eventCallbackProxy(event);
-              });
-            }
-            eventsToDispatch.length = 0;
-          }
-        });
-      });
-
-      const addEventListener = self.addEventListener;
-      self.addEventListener = function (eventName, callback, options) {
-        if (eventsToCatch.indexOf(eventName) > -1) {
-          eventCallbackProxies[eventName] = callback;
-          return null;
-        }
-        return addEventListener.call(self, eventName, callback, options);
-      };
-    } else {
-      const eventsToCatch = ["message"];
-      eventsToCatch.forEach((eventName) => {
-        var eventQueue = [];
-        var eventCallback = (event) => {
-          eventQueue.push(event);
-        };
-        self.addEventListener(eventName, eventCallback);
-        firstImportCallbacks.push(() => {
-          self.removeEventListener(eventName, eventCallback);
-          eventQueue.forEach(function (event) {
-            self.dispatchEvent(event);
-          });
-          eventQueue.length = 0;
-        });
-      });
-    }
-
-    System.register = async (deps, declare) => {
-      System.register = () => {
-        throw new Error(
-          "unexpected call to System.register (called outside url instantiation)",
-        );
-      };
-      const url = self.location.href;
-      registerRegistry[url] = [deps, declare];
-      const namespace = await _import(url);
-      firstImportCallbacks.forEach((firstImportCallback) => {
-        firstImportCallback();
-      });
-      firstImportCallbacks.length = 0;
-      return namespace;
-    };
-    System.instantiate = async (url) => {
-      const response = await self.fetch(url, {
-        credentials: "same-origin",
-      });
-      if (!response.ok) {
-        throw Error(`Failed to fetch module at ${url}`);
-      }
-      let source = await response.text();
-      if (source.indexOf("//# sourceURL=") < 0) {
-        source += `\n//# sourceURL=${url}`;
-      }
-      const register = System.register;
-      System.register = (deps, declare) => {
-        registerRegistry[url] = [deps, declare];
-      };
-      (0, self.eval)(source);
-      System.register = register;
-    };
-  }
-
-  const _import = (specifier, parentUrl) => {
-    const url = resolveUrl(specifier, parentUrl);
-    const load = getOrCreateLoad(url, parentUrl);
-    if (load.completionPromise) {
-      if (load.completionPromise === load.namespace) {
-        return Promise.resolve(load.namespace);
-      }
-      return load.completionPromise;
-    }
-    return startExecution(load, parentUrl);
-  };
-
-  const getOrCreateLoad = (url, firstParentUrl) => {
-    const existingLoad = loadRegistry[url];
-    if (existingLoad) {
-      return existingLoad;
-    }
-    const namespace = createNamespace();
-    const load = {
-      url,
-      deps: [],
-      dependencyLoads: [],
-      instantiatePromise: null,
-      linkPromise: null,
-      executePromise: null,
-      completionPromise: null,
-      importerSetters: [],
-      setters: [],
-      execute: null,
-      error: null,
-      hoistedExports: false,
-      namespace,
-    };
-    loadRegistry[url] = load;
-    load.instantiatePromise = (async () => {
-      try {
-        let registration = registerRegistry[url];
-        if (!registration) {
-          const instantiateReturnValue = System.instantiate(
-            url,
-            firstParentUrl,
-          );
-          if (instantiateReturnValue) {
-            await instantiateReturnValue;
-          }
-          registration = registerRegistry[url];
-        }
-        if (!registration) {
-          throw new Error(
-            `System.register() not called after executing ${url}`,
-          );
-        }
-
-        const _export = (firstArg, secondArg) => {
-          load.hoistedExports = true;
-          let changed = false;
-          if (typeof firstArg === "string") {
-            const name = firstArg;
-            const value = secondArg;
-            if (!(name in namespace) || namespace[name] !== value) {
-              namespace[name] = value;
-              changed = true;
-            }
-          } else {
-            Object.keys(firstArg).forEach((name) => {
-              const value = firstArg[name];
-              if (!(name in namespace) || namespace[name] !== value) {
-                namespace[name] = value;
-                changed = true;
-              }
-            });
-            if (firstArg && firstArg.__esModule) {
-              namespace.__esModule = firstArg.__esModule;
-            }
-          }
-          if (changed) {
-            load.importerSetters.forEach((importerSetter) => {
-              if (importerSetter) {
-                importerSetter(namespace);
-              }
-            });
-          }
-          return secondArg;
-        };
-        const [deps, declare] = registration;
-        const { setters, execute = () => {} } = declare(_export, {
-          import: (importId) => _import(importId, url),
-          meta: createMeta(url),
-        });
-        load.deps = deps;
-        load.setters = setters;
-        load.execute = execute;
-      } catch (e) {
-        load.error = e;
-        load.execute = null;
-      }
-    })();
-    load.linkPromise = (async () => {
-      await load.instantiatePromise;
-      const dependencyLoads = await Promise.all(
-        load.deps.map(async (dep, index) => {
-          const setter = load.setters[index];
-          const dependencyUrl = resolveUrl(dep, url);
-          const dependencyLoad = getOrCreateLoad(dependencyUrl, url);
-          if (dependencyLoad.instantiatePromise) {
-            await dependencyLoad.instantiatePromise;
-          }
-          if (setter) {
-            dependencyLoad.importerSetters.push(setter);
-            if (
-              dependencyLoad.hoistedExports ||
-              !dependencyLoad.instantiatePromise
-            ) {
-              setter(dependencyLoad.namespace);
-            }
-          }
-          return dependencyLoad;
-        }),
-      );
-      load.dependencyLoads = dependencyLoads;
-    })();
-    return load;
-  };
-
-  const startExecution = async (load, importerUrl) => {
-    load.completionPromise = (async () => {
-      await instantiateAll(load, load, {});
-      await postOrderExec(load, importerUrl ? [importerUrl] : []);
-      return load.namespace;
-    })();
-    return load.completionPromise;
-  };
-
-  const instantiateAll = async (load, parent, loaded) => {
-    if (loaded[load.url]) {
-      return;
-    }
-    loaded[load.url] = true;
-    try {
-      if (load.linkPromise) {
-        // load.linkPromise is null once instantiated
-        await load.linkPromise;
-      }
-      await Promise.all(
-        load.dependencyLoads.map((dependencyLoad) => {
-          return instantiateAll(dependencyLoad, parent, loaded);
-        }),
-      );
-    } catch (error) {
-      if (load.error) {
-        throw error;
-      }
-      load.execute = null;
-      throw error;
-    }
-  };
-
-  const postOrderExec = (load, importStack) => {
-    if (importStack.indexOf(load.url) > -1) {
-      return undefined;
-    }
-    if (!load.execute) {
-      if (load.error) {
-        throw load.error;
-      }
-      if (load.executePromise) {
-        return load.executePromise;
-      }
-      return undefined;
-    }
-
-    // deps execute first, unless circular
-    const execute = load.execute;
-    load.execute = null;
-    const depLoadPromises = [];
-    load.dependencyLoads.forEach((dependencyLoad) => {
-      try {
-        const depImportStack = importStack.slice();
-        depImportStack.push(load.url);
-        const depLoadPromise = postOrderExec(dependencyLoad, depImportStack);
-        if (depLoadPromise) {
-          depLoadPromises.push(depLoadPromise);
-        }
-      } catch (err) {
-        load.error = err;
-        throw err;
-      }
-    });
-
-    return (async () => {
-      if (depLoadPromises.length) {
-        const allDepPromise = Promise.all(depLoadPromises);
-        await allDepPromise;
-      }
-
-      try {
-        const executeReturnValue = execute.call(nullContext);
-        if (executeReturnValue) {
-          load.executePromise = executeReturnValue.then(
-            () => {
-              load.executePromise = null;
-              load.completionPromise = load.namespace;
-            },
-            (error) => {
-              load.executePromise = null;
-              load.error = error;
-              throw error;
-            },
-          );
-          return;
-        }
-        load.instantiatePromise = null;
-        load.linkPromise = null;
-        load.completionPromise = load.namespace;
-      } catch (error) {
-        load.error = error;
-        throw error;
-      } finally {
-        load.execute = null;
-      }
-    })();
-  };
-
-  // the closest we can get to call(undefined)
-  const nullContext = Object.freeze(Object.create(null));
-
-  const createMeta = (url) => {
-    return {
-      url,
-      resolve: (id) => resolveUrl(id, url),
-    };
-  };
-
-  const createNamespace =
-    typeof Symbol !== "undefined" && Symbol.toStringTag
-      ? () => {
-          const namespace = Object.create(null);
-          Object.defineProperty(namespace, Symbol.toStringTag, {
-            value: "Module",
-          });
-          return namespace;
-        }
-      : () => Object.create(null);
-})();

package/src/plugins/transpilation/js_module_fallback/convert_js_module_to_js_classic.js

@@ -1,175 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/urls";
-import { readFileSync } from "@jsenv/filesystem";
-import {
-  createMagicSource,
-  composeTwoSourcemaps,
-  SOURCEMAP,
-} from "@jsenv/sourcemap";
-import { applyBabelPlugins } from "@jsenv/ast";
-
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
-import { requireBabelPlugin } from "../babel/require_babel_plugin.js";
-import { babelPluginTransformImportMetaUrl } from "./helpers/babel_plugin_transform_import_meta_url.js";
-import { babelPluginTransformImportMetaResolve } from "./helpers/babel_plugin_transform_import_meta_resolve.js";
-
-// because of https://github.com/rpetrich/babel-plugin-transform-async-to-promises/issues/84
-import customAsyncToPromises from "./async-to-promises.js";
-
-export const systemJsClientFileUrlDefault = new URL(
-  "./client/s.js",
-  import.meta.url,
-).href;
-
-export const convertJsModuleToJsClassic = async ({
-  systemJsInjection,
-  systemJsClientFileUrl = systemJsClientFileUrlDefault,
-  urlInfo,
-  jsModuleUrlInfo,
-}) => {
-  let jsClassicFormat;
-  if (urlInfo.isEntryPoint && !jsModuleUrlInfo.data.usesImport) {
-    // if it's an entry point without dependency (it does not use import)
-    // then we can use UMD
-    jsClassicFormat = "umd";
-  } else {
-    // otherwise we have to use system in case it's imported
-    // by an other file (for entry points)
-    // or to be able to import when it uses import
-    jsClassicFormat = "system";
-  }
-
-  urlInfo.data.jsClassicFormat = jsClassicFormat;
-  const { code, map } = await applyBabelPlugins({
-    babelPlugins: [
-      ...(jsClassicFormat === "system"
-        ? [
-            // proposal-dynamic-import required with systemjs for babel8:
-            // https://github.com/babel/babel/issues/10746
-            requireFromJsenv("@babel/plugin-proposal-dynamic-import"),
-            requireFromJsenv("@babel/plugin-transform-modules-systemjs"),
-            [babelPluginRelativeImports, { rootUrl: jsModuleUrlInfo.url }],
-            [
-              customAsyncToPromises,
-              {
-                asyncAwait: false, // already handled + we might not needs it at all
-                topLevelAwait: "return",
-              },
-            ],
-          ]
-        : [
-            [
-              requireBabelPlugin("babel-plugin-transform-async-to-promises"),
-              {
-                asyncAwait: false, // already handled + we might not needs it at all
-                topLevelAwait: "simple",
-              },
-            ],
-            babelPluginTransformImportMetaUrl,
-            babelPluginTransformImportMetaResolve,
-            requireFromJsenv("@babel/plugin-transform-modules-umd"),
-            [babelPluginRelativeImports, { rootUrl: jsModuleUrlInfo.url }],
-          ]),
-    ],
-    urlInfo: jsModuleUrlInfo,
-  });
-  let sourcemap = jsModuleUrlInfo.sourcemap;
-  sourcemap = await composeTwoSourcemaps(sourcemap, map);
-  if (
-    systemJsInjection &&
-    jsClassicFormat === "system" &&
-    urlInfo.isEntryPoint
-  ) {
-    const magicSource = createMagicSource(code);
-    let systemJsFileContent = readFileSync(systemJsClientFileUrl, {
-      as: "string",
-    });
-    const sourcemapFound = SOURCEMAP.readComment({
-      contentType: "text/javascript",
-      content: systemJsFileContent,
-    });
-    if (sourcemapFound) {
-      // for now let's remove s.js sourcemap
-      // because it would likely mess the sourcemap of the entry point itself
-      systemJsFileContent = SOURCEMAP.writeComment({
-        contentType: "text/javascript",
-        content: systemJsFileContent,
-        specifier: "",
-      });
-    }
-    magicSource.prepend(`${systemJsFileContent}\n\n`);
-    const magicResult = magicSource.toContentAndSourcemap();
-    sourcemap = await composeTwoSourcemaps(sourcemap, magicResult.sourcemap);
-    return {
-      content: magicResult.content,
-      sourcemap,
-    };
-  }
-  return {
-    content: code,
-    sourcemap,
-  };
-};
-
-/*
- * When systemjs or umd format is used by babel, it will generated UID based on
- * the import specifier:
- * https://github.com/babel/babel/blob/97d1967826077f15e766778c0d64711399e9a72a/packages/babel-plugin-transform-modules-systemjs/src/index.ts#L498
- * But at this stage import specifier are absolute file urls
- * This can be mitigated by minification that will rename them.
- * But to fix this issue once and for all there is babelPluginRelativeImports below
- */
-const babelPluginRelativeImports = (babel) => {
-  const t = babel.types;
-
-  const replaceSpecifierAtPath = (path, state) => {
-    const specifier = path.node.value;
-    if (specifier.startsWith("file://")) {
-      const specifierRelative = urlToRelativeUrl(specifier, state.opts.rootUrl);
-      path.replaceWith(t.stringLiteral(specifierRelative));
-    }
-  };
-
-  return {
-    name: "relative-imports",
-    visitor: {
-      CallExpression: (path, state) => {
-        if (path.node.callee.type !== "Import") {
-          // Some other function call, not import();
-          return;
-        }
-        if (path.node.arguments[0].type !== "StringLiteral") {
-          // Non-string argument, probably a variable or expression, e.g.
-          // import(moduleId)
-          // import('./' + moduleName)
-          return;
-        }
-        const sourcePath = path.get("arguments")[0];
-        if (sourcePath.node.type === "StringLiteral") {
-          replaceSpecifierAtPath(sourcePath, state);
-        }
-      },
-      ImportDeclaration: (path, state) => {
-        const sourcePath = path.get("source");
-        replaceSpecifierAtPath(sourcePath, state);
-      },
-      ExportAllDeclaration: (path, state) => {
-        const sourcePath = path.get("source");
-        replaceSpecifierAtPath(sourcePath, state);
-      },
-      ExportNamedDeclaration: (path, state) => {
-        if (!path.node.source) {
-          // This export has no "source", so it's probably
-          // a local variable or function, e.g.
-          // export { varName }
-          // export const constName = ...
-          // export function funcName() {}
-          return;
-        }
-        const sourcePath = path.get("source");
-        if (sourcePath.node.type === "StringLiteral") {
-          replaceSpecifierAtPath(sourcePath, state);
-        }
-      },
-    },
-  };
-};

package/src/plugins/transpilation/js_module_fallback/helpers/babel_plugin_transform_import_meta_resolve.js

@@ -1,26 +0,0 @@
-export const babelPluginTransformImportMetaResolve = () => {
-  return {
-    name: "transform-import-meta-resolve",
-    visitor: {
-      Program: (programPath) => {
-        programPath.traverse({
-          MemberExpression: (path) => {
-            const node = path.node;
-            if (
-              node.object.type === "MetaProperty" &&
-              node.object.property.name === "meta" &&
-              node.property.name === "resolve"
-            ) {
-              const firstArg = node.arguments[0];
-              if (firstArg && firstArg.type === "StringLiteral") {
-                path.replaceWithSourceString(
-                  `new URL(${firstArg.value}, document.currentScript.src).href`,
-                );
-              }
-            }
-          },
-        });
-      },
-    },
-  };
-};

package/src/plugins/transpilation/js_module_fallback/helpers/babel_plugin_transform_import_meta_url.js

@@ -1,47 +0,0 @@
-import babelParser from "@babel/parser";
-
-export const babelPluginTransformImportMetaUrl = (babel) => {
-  return {
-    name: "transform-import-meta-url",
-    visitor: {
-      Program: (programPath) => {
-        const currentUrlIdentifier =
-          programPath.scope.generateUidIdentifier("currentUrl");
-        let used = false;
-
-        programPath.traverse({
-          MemberExpression: (path) => {
-            const node = path.node;
-            if (
-              node.object.type === "MetaProperty" &&
-              node.object.property.name === "meta" &&
-              node.property.name === "url"
-            ) {
-              // const node = babel.types.valueToNode(10)
-              const identifier = babel.types.identifier(
-                currentUrlIdentifier.name,
-              );
-              const expressionStatement =
-                babel.types.expressionStatement(identifier);
-              path.replaceWith(expressionStatement);
-              used = true;
-            }
-          },
-        });
-        if (used) {
-          const ast = generateExpressionAst(`document.currentScript.src`);
-          programPath.scope.push({
-            id: currentUrlIdentifier,
-            init: ast,
-          });
-        }
-      },
-    },
-  };
-};
-
-const generateExpressionAst = (expression, options) => {
-  const { parseExpression } = babelParser;
-  const ast = parseExpression(expression, options);
-  return ast;
-};