jspm 4.0.2 → 4.1.0

package/dist/cli.js

@@ -2326,7 +2326,7 @@ async function writeHtmlOutput(mapFile, generator, pins, env2, flags, silent = f
     htmlUrl: generator.mapUrl,
     // URL of the output map
     rootUrl: generator.rootUrl,
-    preload: getPreloadMode(flags),
+    preload: flags.release ? true : getPreloadMode(flags),
     integrity: flags.integrity,
     whitespace: !flags.compact,
     comment: false
@@ -2403,8 +2403,8 @@ async function getGenerator(flags, configOverride = null, inputMap) {
         rootUrl,
         inputMap: inputMap || await getInputMap(flags),
         env: await getEnv(flags),
-        flattenScopes: flags.flattenScopes,
-        combineSubpaths: flags.combineSubpaths,
+        flattenScopes: flags.flattenScopes === false ? false : flags.release || flags.flattenScopes,
+        combineSubpaths: flags.combineSubpaths === false ? false : flags.release || flags.combineSubpaths,
         defaultProvider,
         resolutions: getResolutions(flags),
         cache: getCacheMode(flags),
@@ -2494,19 +2494,23 @@ function getInputPath(flags, fallbackDefaultMap = defaultMapPath) {
   if (mapPath) {
     return resolve(mapPath);
   }
-  if (exists(defaultMapPath)) {
-    return resolve(defaultMapPath);
+  const defaultMapPathResolved = resolve(flags.dir ?? ".", defaultMapPath);
+  if (exists(defaultMapPathResolved)) {
+    return defaultMapPathResolved;
   }
-  return resolve(fallbackDefaultMap);
+  const fallbackDefaultMapResolved = resolve(flags.dir ?? ".", fallbackDefaultMap);
+  return fallbackDefaultMapResolved;
 }
 function getOutputPath(flags) {
   if (flags.out || flags.map) {
     return resolve(flags.out || flags.map);
   }
-  if (exists(defaultMapPath)) {
-    return resolve(defaultMapPath);
+  const defaultMapPathResolved = resolve(flags.dir ?? ".", defaultMapPath);
+  if (defaultMapPathResolved) {
+    return defaultMapPathResolved;
   }
-  return resolve(defaultMapPath);
+  const fallbackDefaultMapResolved = resolve(flags.dir ?? ".", defaultMapPath);
+  return fallbackDefaultMapResolved;
 }
 function getOutputMapUrl(flags) {
   return pathToFileURL(getOutputPath(flags));
@@ -2539,9 +2543,8 @@ function addEnvs(env2, newEnvs) {
   return env2.sort();
 }
 async function getEnv(flags) {
-  const inputMap = await getInputMap(flags);
   const envFlags = Array.isArray(flags?.conditions) ? flags.conditions : (flags.conditions || "").split(",").map((e) => e.trim()).filter(Boolean);
-  let env2 = inputMap.env || ["development", "browser", "module"];
+  let env2 = ["browser", "module", flags.release ? "production" : "development"];
   env2 = removeEnvs(
     env2,
     envFlags.filter((env3) => env3.startsWith("no-")).map((env3) => env3.slice(3))
@@ -3378,7 +3381,7 @@ ${c6.green("Ok:")} Initialization complete.`);
   }
 }
 async function initProject(flags) {
-  const directory = flags.dir || process.cwd();
+  const directory = process.cwd();
   if (!await isDirectory(directory)) {
     throw new JspmError(`Directory does not exist: ${directory}`);
   }
@@ -29205,7 +29208,7 @@ async function build(flags) {
       format: "esm",
       assetFileNames: "[name][extname]",
       entryFileNames: "[name]",
-      chunkFileNames: "[name]",
+      chunkFileNames: "lib/[name]-[hash:8].js",
       sourcemap: true,
       compact: flags.minify
     });
@@ -29219,7 +29222,18 @@ async function build(flags) {
         await writeFile3(`${outPath}.map`, JSON.stringify(chunk.map));
       }
     }
-    const generatedFiles = new Set(output.map((chunk) => chunk.fileName));
+    const projectBase = `${pathToFileURL4(projectConfig.projectPath).href}/`;
+    const generatedFiles = /* @__PURE__ */ new Set();
+    for (const chunk of output) {
+      generatedFiles.add(chunk.fileName);
+      if (chunk.type === "chunk") {
+        for (const refFile of chunk.moduleIds) {
+          if (refFile.startsWith(projectBase)) {
+            generatedFiles.add(relative3(projectBase, refFile).replace(/\\/g, "/"));
+          }
+        }
+      }
+    }
     {
       const pjson = JSON.parse(
         readFileSync2(join3(projectConfig.projectPath, "package.json"), "utf8")
@@ -29244,8 +29258,44 @@ async function build(flags) {
       }
     }
     stopSpinner();
+    if (flags.install !== false) {
+      if (!flags.quiet) {
+        console.log(`${c11.cyan("Info:")} Generating import map in build directory...`);
+      }
+      const map = getInputPath(flags);
+      process.chdir(flags.out);
+      const installFlags = {
+        ...flags,
+        // use local map as source of truth for resolutions
+        map,
+        // output to default importmap.js in build dir
+        out: getOutputPath({}),
+        dir: void 0,
+        release: true,
+        quiet: true
+      };
+      try {
+        await install(installFlags);
+        if (!flags.quiet) {
+          console.log(`${c11.green("\u2713")} Import map generated in ${c11.cyan(flags.out)}`);
+        }
+      } catch (error2) {
+        if (!flags.quiet) {
+          console.warn(`${c11.yellow("Warning:")} Failed to generate import map: ${error2.message}`);
+        }
+      }
+    }
     if (!flags.quiet) {
-      console.log(`${c11.green("\u2713")} Built ${c11.cyan(projectConfig.name)} to ${c11.cyan(flags.out)}`);
+      const infoMsg = flags.install !== false ? `${c11.green("\u2713")} Built ${c11.cyan(projectConfig.name)} to ${c11.cyan(
+        flags.out
+      )} with import map.` : `${c11.green("\u2713")} Built ${c11.cyan(projectConfig.name)} to ${c11.cyan(
+        flags.out
+      )}.
+
+${c11.cyan("Info:")} Run ${c11.bold(
+        `jspm -d ${flags.out} install --release`
+      )} to create a production import map.`;
+      console.log(infoMsg);
     }
   } catch (e) {
     stopSpinner();
@@ -32311,12 +32361,12 @@ ${error2.snippet}`
                   file: relativePath2,
                   name: `Bare module specifier import ${c15.bold(
                     c15.cyan(`'${module}'`)
-                  )} is not mapped by the import map`,
+                  )} is not mapped by the import map. Either update the package.json "name" or update the HTML to use an import of "jspm" or "jspm/...".`,
                   description: `Only bare specifiers matching the project name ${c15.cyan(
                     c15.bold(`'${projectConfig.name}'`)
                   )} are mapped.`,
                   code: {
-                    title: "package.json:",
+                    title: "Correct JSPM HTML Script:",
                     snippet: `<script type="module">import '${projectConfig.name}';</script>`
                   }
                 });
@@ -32750,31 +32800,33 @@ ${c16.yellow("...")}${c16.bold(remainingCount)} more ${remainingCount === 1 ? "i
 init_init();
 var { version: version2 } = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
 var cli = dist_default(c17.yellow("jspm"));
-var generateOpts = (cac2, production = false) => cac2.option(
+var generateOpts = (cac2, release = false) => cac2.option(
   "-m, --map <file>",
   "File containing initial import map (defaults to importmap.json, supports .js with a JSON import map embedded, or HTML with an inline import map)",
   {}
 ).option("-C, --conditions <environments>", "Comma-separated environment condition overrides", {
-  default: production ? ["browser", "production", "module"] : ["browser", "development", "module"]
+  default: []
 }).option("-r, --resolution <resolutions>", "Comma-separated dependency resolution overrides", {}).option(
   "-p, --provider <provider>",
   `Default module provider. Available providers: ${availableProviders.join(", ")}`,
   {}
 ).option("--cache <mode>", "Cache mode for fetches (online, offline, no-cache)", {
   default: "online"
-});
-var outputOpts = (cac2, production = false) => cac2.option("--integrity", "Add module integrity attributes to the import map", { default: false }).option("--preload [mode]", "Add module preloads to HTML output (default: static, dynamic)", {}).option("--root <url>", "URL to treat as server root, i.e. rebase import maps against", {}).option(
-  "-f, --flatten-scopes",
-  "Flatten import map scopes into smaller single top-level scope per origin",
+}).option(
+  "--release",
+  "Enable release mode (--flatten-scopes, --combine-subpaths, --C=production)",
   {
-    default: production
+    default: release
   }
+);
+var outputOpts = (cac2) => cac2.option("--integrity", "Add module integrity attributes to the import map", {}).option("--preload [mode]", "Add module preloads to HTML output (default: static, dynamic)", {}).option("--root <url>", "URL to treat as server root, i.e. rebase import maps against", {}).option(
+  "-f, --flatten-scopes",
+  "Flatten import map scopes into smaller single top-level scope per origin",
+  {}
 ).option(
   "-s, --combine-subpaths",
   "Combine import map subpaths under folder maps (ending in /)",
-  {
-    default: production
-  }
+  {}
 ).option("-c, --compact", "Output a compact import map", { default: false }).option("--stdout", "Output the import map to stdout", { default: false }).option(
   "-o, --out <file>",
   "File to inject the final import map into (default: --map / importmap.js). For JS files outputs an injection wrapper script, for JSON files, the import map only, and for HTML files embeds the import map.",
@@ -32982,7 +33034,7 @@ Start a server that uses importmap.json as the import map.
 `
 ).example(
   (name) => `
-$ ${name} serve --no-watch --no-install --no-type-stripping
+$ ${name} serve --static
     
 Start a server that does not generate the import map on startup, perform type stripping or provide a hot reload watcher
 `
@@ -33016,12 +33068,16 @@ the same options as the 'jspm install' command with no arguments.
 `
 ).action(wrapCommand(serve));
 generateOpts(
-  cli.command("build", "Build package").option("--no-minify", "Disable build minification", {
-    default: true
-  }).option("-o, --out <dir>", "Path to the output directory for the build", {
-    default: "dist"
-  }),
-  true
+  outputOpts(
+    cli.command("build", "Build package").option("--no-minify", "Disable build minification", {
+      default: true
+    }).option("-o, --out <dir>", "Path to the output directory for the build", {
+      default: "dist"
+    }).option("--install", "Generate import map after build completes", {
+      default: true
+    }),
+    true
+  )
 ).example(
   (name) => `
 $ ${name} build
@@ -33054,8 +33110,19 @@ Uses RollupJS under the hood to create optimized bundles.
 
 The package entry points as defined in the package.json "exports" field are built, with the
 entire package copied into the output directory. As such, it is a whole-package transformation.
+
+Build externals are taken from the package.json "dependencies" to form a roughly configurationless
+build workflow (dependencies in "devDependencies" or otherwise are inlined into the build).
+
 Includes and ignores can be specified using the package.json "files" and "ignore" fields,
 optionally using the JSPM overrides for these via the "jspm" property in the package.json.
+
+Any build import map shoud be generated separately via a subsequent install operation on the
+build folder, for example like:
+
+${c17.bold("jspm install -d dist -C production --flatten-scopes --combine-subpaths")}
+
+to generate an optimized production map.
 `
 ).action(wrapCommand(build));
 outputOpts(
@@ -33078,8 +33145,7 @@ outputOpts(
       {}
     ).option("--eject <package>", "Eject a published package instead of publishing", {}),
     true
-  ),
-  true
+  )
 ).example(
   (name) => `
 $ ${name} publish

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jspm",
   "type": "module",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "Import Map Package Manager",
   "license": "Apache-2.0",
   "bin": {