@granite-js/mpack 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @granite-js/mpack
 
+## 0.1.12
+
+### Patch Changes
+
+- d1e6585: fix module resolutions
+- Updated dependencies [d1e6585]
+- Updated dependencies [1e99fe1]
+  - @granite-js/devtools-frontend@0.1.12
+  - @granite-js/plugin-core@0.1.12
+  - @granite-js/utils@0.1.12
+
+## 0.1.11
+
+### Patch Changes
+
+- 12f568f: improve error handler
+- d3a2b58: improve resolver plugin
+- Updated dependencies [d3a2b58]
+  - @granite-js/plugin-core@0.1.11
+  - @granite-js/devtools-frontend@0.1.11
+  - @granite-js/utils@0.1.11
+
 ## 0.1.10
 
 ### Patch Changes

package/dist/bundler/Bundler.js

@@ -39,7 +39,7 @@ var import_plugins = require("./plugins");
 var import_constants = require("../constants");
 var import_logger = require("../logger");
 var import_getId = require("../utils/getId");
-var import_promiseHandler = require("../utils/promiseHandler");
+var import_promise = require("../utils/promise");
 var import_presets = require("./internal/presets");
 class Bundler {
   constructor(config) {
@@ -69,7 +69,7 @@ class Bundler {
     if (this.status === "prepared" || this.status === "building") {
       this.bundleTask?.abort();
     }
-    this.bundleTask = new import_promiseHandler.PromiseHandler(this.revisionId++);
+    this.bundleTask = new import_promise.PromiseHandler(this.revisionId++);
     this.esbuildContext.rebuild();
     this.status = "prepared";
     const result = await this.bundleTask.wait();
@@ -141,7 +141,7 @@ class Bundler {
           onLoad: (moduleCount) => this.handleLoad(moduleCount),
           onEnd: (buildResult) => this.handleEnd(buildResult)
         }),
-        (0, import_plugins.dependencyAliasPlugin)({ context: pluginContext }),
+        (0, import_plugins.resolvePlugin)({ context: pluginContext }),
         (0, import_plugins.requireContextPlugin)(),
         (0, import_plugins.transformPlugin)({
           context: pluginContext,

package/dist/bundler/plugins/buildStatusPlugin/buildStatusPlugin.js

@@ -44,30 +44,34 @@ function buildStatusPlugin({ context, ...hooks }) {
       });
       build.onEnd(async (result) => {
         const endAt = performance.now();
+        const duration = endAt - buildStartedAt;
         const { buildConfig } = context.config;
         const { outfile, sourcemapOutfile, platform, extra } = buildConfig;
         const { source, sourcemap } = (0, import_getBundleOutputs.getBundleOutputs)(outfile, result);
-        const duration = endAt - buildStartedAt;
-        if (source && sourcemap) {
-          Object.defineProperties(result, {
-            bundle: { value: { source, sourcemap }, enumerable: true },
-            outfile: { value: outfile, enumerable: true },
-            sourcemapOutfile: { value: sourcemapOutfile ?? (0, import_getSourcemapName.getSourcemapName)(outfile), enumerable: true },
-            platform: { value: platform, enumerable: true },
-            extra: { value: extra, enumerable: true },
-            totalModuleCount: { value: moduleCount, enumerable: true },
-            duration: { value: duration, enumerable: true },
-            size: { value: source.contents.byteLength, enumerable: true }
-          });
-          import_logger.logger.debug("Build completed", { id: context.id });
-          await hooks.onEnd(result);
-        } else {
-          throw new Error("invalid bundle result");
-        }
+        const buildResult = extendBuildResult(
+          result,
+          source && sourcemap ? {
+            bundle: { source, sourcemap },
+            outfile,
+            sourcemapOutfile: sourcemapOutfile ?? (0, import_getSourcemapName.getSourcemapName)(outfile),
+            platform,
+            extra,
+            duration,
+            size: source.contents.byteLength,
+            totalModuleCount: moduleCount
+          } : { platform, extra, duration }
+        );
+        await hooks.onEnd(buildResult);
       });
     }
   };
 }
+function extendBuildResult(result, properties) {
+  return Object.defineProperties(
+    result,
+    Object.fromEntries(Object.entries(properties).map(([property, value]) => [property, { value, enumerable: true }]))
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildStatusPlugin

package/dist/bundler/plugins/index.d.ts

@@ -1,4 +1,4 @@
 export * from './buildStatusPlugin';
-export * from './dependencyAliasPlugin';
+export * from './resolvePlugin';
 export * from './requireContextPlugin';
 export * from './transformPlugin';

package/dist/bundler/plugins/index.js

@@ -16,13 +16,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var plugins_exports = {};
 module.exports = __toCommonJS(plugins_exports);
 __reExport(plugins_exports, require("./buildStatusPlugin"), module.exports);
-__reExport(plugins_exports, require("./dependencyAliasPlugin"), module.exports);
+__reExport(plugins_exports, require("./resolvePlugin"), module.exports);
 __reExport(plugins_exports, require("./requireContextPlugin"), module.exports);
 __reExport(plugins_exports, require("./transformPlugin"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./buildStatusPlugin"),
-  ...require("./dependencyAliasPlugin"),
+  ...require("./resolvePlugin"),
   ...require("./requireContextPlugin"),
   ...require("./transformPlugin")
 });

package/dist/bundler/plugins/resolveHelpers.d.ts

@@ -0,0 +1,3 @@
+import type { OnResolveArgs, PluginBuild, ResolveOptions } from 'esbuild';
+export declare function createNonRecursiveResolver(build: PluginBuild): (args: OnResolveArgs, options: ResolveOptions) => Promise<import("esbuild").ResolveResult> | null;
+export declare function isResolved(args: OnResolveArgs): any;

package/dist/bundler/plugins/resolveHelpers.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveHelpers_exports = {};
+__export(resolveHelpers_exports, {
+  createNonRecursiveResolver: () => createNonRecursiveResolver,
+  isResolved: () => isResolved
+});
+module.exports = __toCommonJS(resolveHelpers_exports);
+const RESOLVED_FLAG_KEY = Symbol.for("mpack:REAOLVED_FLAG");
+function createNonRecursiveResolver(build) {
+  return (args, options) => {
+    if (args.pluginData?.[RESOLVED_FLAG_KEY]) {
+      return null;
+    }
+    const pluginDataWithResolvedFlag = {
+      ...options?.pluginData,
+      [RESOLVED_FLAG_KEY]: true
+    };
+    return build.resolve(args.path, { ...options, pluginData: pluginDataWithResolvedFlag });
+  };
+}
+function isResolved(args) {
+  return args.pluginData?.[RESOLVED_FLAG_KEY];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNonRecursiveResolver,
+  isResolved
+});

package/dist/bundler/plugins/resolvePlugin/alias/setupAliasResolver.d.ts

@@ -0,0 +1,3 @@
+import type { AliasConfig } from '@granite-js/plugin-core';
+import type { PluginBuild } from 'esbuild';
+export declare function setupAliasResolver(build: PluginBuild, aliasConfig: AliasConfig[]): void;

package/dist/bundler/plugins/resolvePlugin/alias/setupAliasResolver.js

@@ -0,0 +1,115 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setupAliasResolver_exports = {};
+__export(setupAliasResolver_exports, {
+  setupAliasResolver: () => setupAliasResolver
+});
+module.exports = __toCommonJS(setupAliasResolver_exports);
+var import_path = __toESM(require("path"));
+var import_es_toolkit = require("es-toolkit");
+var import_performance = require("../../../../performance");
+var import_esbuildUtils = require("../../../../utils/esbuildUtils");
+var import_replaceModulePath = require("../../../../utils/replaceModulePath");
+var import_resolveHelpers = require("../../resolveHelpers");
+var import_swc = require("../../shared/swc");
+function setupAliasResolver(build, aliasConfig) {
+  const resolver = (0, import_resolveHelpers.createNonRecursiveResolver)(build);
+  [import_swc.swcHelperOptimizationRules.getAliasConfig(), ...aliasConfig].forEach((aliasConfig2) => {
+    const resolveResultCache = /* @__PURE__ */ new Map();
+    const { filter, resolveAlias } = resolveAliasConfig(build, aliasConfig2);
+    build.onResolve({ filter }, async (args) => {
+      if ((0, import_resolveHelpers.isResolved)(args)) {
+        return null;
+      }
+      const trace = import_performance.Performance.trace("alias-resolver", {
+        detail: { pattern: filter, path: args.path }
+      });
+      const defaultResolveOptions = {
+        resolveDir: args.resolveDir,
+        importer: args.importer,
+        kind: args.kind,
+        with: args.with
+      };
+      const resolveResult = await resolveAlias(args);
+      const resolvePath = resolveResult.path;
+      const resolveOptions = { ...defaultResolveOptions, ...resolveResult.options ?? {} };
+      const cacheKey = `${resolveOptions.kind}:${resolveOptions.resolveDir}:${resolvePath}`;
+      if (resolveResultCache.has(cacheKey)) {
+        trace.stop({ detail: { cacheHit: true } });
+        return resolveResultCache.get(cacheKey);
+      }
+      if (import_path.default.isAbsolute(resolvePath)) {
+        trace.stop({ detail: { isAbsolute: true } });
+        const result2 = { path: resolvePath };
+        resolveResultCache.set(cacheKey, result2);
+        return result2;
+      }
+      const pathOverriddenArgs = { ...args, path: resolvePath };
+      const result = await resolver(pathOverriddenArgs, resolveOptions);
+      if (result) {
+        trace.stop({ detail: { cacheHit: false, isAbsolute: false } });
+        resolveResultCache.set(cacheKey, result);
+        return result;
+      }
+      return null;
+    });
+  });
+}
+function resolveAliasConfig(build, aliasConfig) {
+  const { from, to, exact } = aliasConfig;
+  const filter = new RegExp(exact ? `^${from}$` : `^${from}(?:$|/)`);
+  const resolver = (0, import_resolveHelpers.createNonRecursiveResolver)(build);
+  const aliasResolver = (boundArgs, path2, options) => {
+    const result = resolver({ ...boundArgs, path: path2 }, options);
+    (0, import_es_toolkit.assert)(result, "resolver should return result");
+    return result;
+  };
+  const resolveAlias = async (args) => {
+    if (typeof to === "string") {
+      return normalizeResolveResult((0, import_replaceModulePath.replaceModulePath)(args.path, from, to));
+    }
+    if (typeof to === "function") {
+      const result = await to({ resolve: aliasResolver.bind(null, args), args });
+      return normalizeResolveResult(result);
+    }
+    return normalizeResolveResult(to);
+  };
+  return { filter, resolveAlias };
+}
+function normalizeResolveResult(result) {
+  if (typeof result === "string") {
+    return { path: (0, import_esbuildUtils.normalizePath)(result), options: void 0 };
+  }
+  const { path: path2, ...options } = result;
+  return { path: path2, options };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupAliasResolver
+});

package/dist/bundler/plugins/resolvePlugin/index.d.ts

@@ -0,0 +1 @@
+export { resolvePlugin } from './resolvePlugin';

package/dist/bundler/plugins/{dependencyAliasPlugin → resolvePlugin}/index.js

@@ -16,13 +16,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dependencyAliasPlugin_exports = {};
-__export(dependencyAliasPlugin_exports, {
-  dependencyAliasPlugin: () => import_dependencyAliasPlugin.dependencyAliasPlugin
+var resolvePlugin_exports = {};
+__export(resolvePlugin_exports, {
+  resolvePlugin: () => import_resolvePlugin.resolvePlugin
 });
-module.exports = __toCommonJS(dependencyAliasPlugin_exports);
-var import_dependencyAliasPlugin = require("./dependencyAliasPlugin");
+module.exports = __toCommonJS(resolvePlugin_exports);
+var import_resolvePlugin = require("./resolvePlugin");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  dependencyAliasPlugin
+  resolvePlugin
 });

package/dist/bundler/plugins/{dependencyAliasPlugin/protocolResolver.js → resolvePlugin/protocol/setupProtocolResolver.js}

@@ -16,12 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var protocolResolver_exports = {};
-__export(protocolResolver_exports, {
+var setupProtocolResolver_exports = {};
+__export(setupProtocolResolver_exports, {
   setupProtocolResolver: () => setupProtocolResolver
 });
-module.exports = __toCommonJS(protocolResolver_exports);
-var import_performance = require("../../../performance");
+module.exports = __toCommonJS(setupProtocolResolver_exports);
+var import_performance = require("../../../../performance");
 function setupProtocolResolver(build, protocolConfig) {
   const protocols = Object.entries(protocolConfig);
   protocols.forEach(([protocol, { resolve, load }]) => {

package/dist/bundler/plugins/resolvePlugin/resolvePlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'esbuild';
+import type { PluginOptions } from '../types';
+export declare function resolvePlugin({ context }: PluginOptions): Plugin;

package/dist/bundler/plugins/{dependencyAliasPlugin/dependencyAliasPlugin.js → resolvePlugin/resolvePlugin.js}

@@ -16,28 +16,27 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dependencyAliasPlugin_exports = {};
-__export(dependencyAliasPlugin_exports, {
-  dependencyAliasPlugin: () => dependencyAliasPlugin
+var resolvePlugin_exports = {};
+__export(resolvePlugin_exports, {
+  resolvePlugin: () => resolvePlugin
 });
-module.exports = __toCommonJS(dependencyAliasPlugin_exports);
-var import_aliasResolver = require("./aliasResolver");
-var import_protocolResolver = require("./protocolResolver");
-function dependencyAliasPlugin({ context }) {
-  const pluginName = "dependency-alias-plugin";
+module.exports = __toCommonJS(resolvePlugin_exports);
+var import_setupAliasResolver = require("./alias/setupAliasResolver");
+var import_setupProtocolResolver = require("./protocol/setupProtocolResolver");
+function resolvePlugin({ context }) {
   return {
-    name: pluginName,
+    name: "resolve-plugin",
     setup(build) {
-      const { rootDir, buildConfig } = context.config;
+      const { buildConfig } = context.config;
       const { resolver } = buildConfig;
       const alias = resolver?.alias ?? [];
       const protocols = resolver?.protocols ?? {};
-      (0, import_aliasResolver.setupAliasResolver)(build, rootDir, alias);
-      (0, import_protocolResolver.setupProtocolResolver)(build, protocols);
+      (0, import_setupAliasResolver.setupAliasResolver)(build, alias);
+      (0, import_setupProtocolResolver.setupProtocolResolver)(build, protocols);
     }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  dependencyAliasPlugin
+  resolvePlugin
 });

package/dist/bundler/plugins/transformPlugin/helpers/preludeScript.d.ts

@@ -1,15 +1,23 @@
 import { OnLoadArgs, PluginBuild } from 'esbuild';
 /**
- * Entry Point 모듈을 찾아 마킹하기 위한 `onResolve` 콜백 등록
+ * Register `onResolve` callback to mark the module as entry point module
  */
 export declare function registerEntryPointMarker(build: PluginBuild): void;
 /**
- * 가상의 Prelude script 경로를 Tree Shaking 없이 직접 resolve 하기 위한 `onResolve` 콜백 등록
+ * Register `onResolve` callback to resolve the virtual prelude script path
+ *
+ * This callback is used to resolve the virtual prelude script path without tree shaking.
+ *
+ * ```ts
+ * import 'prelude:foo';
+ * import 'prelude:bar';
+ * import 'prelude:baz';
+ * ```
  */
 export declare function registerPreludeScriptResolver(build: PluginBuild): void;
 export declare function isEntryPoint(args: OnLoadArgs): boolean;
 /**
- * 코드 최상단에 prelude 스크립트 추가
+ * Returns string that inject prelude script at the top of the code
  *
  * ```ts
  * import 'prelude:foo';

package/dist/bundler/plugins/transformPlugin/helpers/preludeScript.js

@@ -38,21 +38,20 @@ var path = __toESM(require("path"));
 var import_es_toolkit = require("es-toolkit");
 var import_constants = require("../../../../constants");
 var import_esbuildUtils = require("../../../../utils/esbuildUtils");
-const skipResolve = Symbol.for("skipResolve");
-const isEntry = Symbol.for("isEntry");
+var import_resolveHelpers = require("../../resolveHelpers");
+const IS_ENTRY_FLAG = Symbol.for("mpack:IS_ENTRY_FLAG");
 function registerEntryPointMarker(build) {
+  const resolver = (0, import_resolveHelpers.createNonRecursiveResolver)(build);
   build.onResolve({ filter: /\.([mc]js|[tj]sx?)$/ }, async (args) => {
-    if (args.pluginData !== skipResolve && args.kind === "entry-point") {
-      const { path: path2, errors } = await build.resolve(args.path, {
-        importer: args.importer,
-        kind: args.kind,
-        resolveDir: args.resolveDir,
-        // 한 번만 resolve 하기 위한 플래그 값
-        pluginData: skipResolve
-      });
-      return errors.length === 0 ? { path: path2, pluginData: isEntry } : { errors };
+    if (args.kind !== "entry-point") {
+      return null;
     }
-    return null;
+    const result = await resolver(args, {
+      importer: args.importer,
+      kind: args.kind,
+      resolveDir: args.resolveDir
+    });
+    return result ? { ...result, pluginData: IS_ENTRY_FLAG } : null;
   });
 }
 function registerPreludeScriptResolver(build) {
@@ -63,7 +62,7 @@ function registerPreludeScriptResolver(build) {
   });
 }
 function isEntryPoint(args) {
-  return args.pluginData === isEntry;
+  return args.pluginData === IS_ENTRY_FLAG;
 }
 function injectPreludeScript(code, {
   preludeScriptPaths

package/dist/operations/build.d.ts

@@ -1,4 +1,4 @@
-import { type BuildConfig, type BuildResult, type CompleteGraniteConfig } from '@granite-js/plugin-core';
+import { type BuildConfig, type CompleteGraniteConfig } from '@granite-js/plugin-core';
 import type { BundlerConfig, PluginFactory } from '../types';
 type CommonBuildOptions = Omit<BundlerConfig, 'rootDir' | 'buildConfig'> & Pick<BuildConfig, 'platform' | 'outfile'>;
 export interface BuildOptions extends CommonBuildOptions {
@@ -10,6 +10,6 @@ export interface BuildAllOptions {
     concurrency?: number;
     plugins?: PluginFactory[];
 }
-export declare function build({ config, plugins, ...options }: BuildOptions): Promise<BuildResult>;
-export declare function buildAll(optionsList: CommonBuildOptions[], { config, plugins, concurrency }: BuildAllOptions): Promise<BuildResult[]>;
+export declare function build({ config, plugins, ...options }: BuildOptions): Promise<import("@granite-js/plugin-core").BuildSuccessResult>;
+export declare function buildAll(optionsList: CommonBuildOptions[], { config, plugins, concurrency }: BuildAllOptions): Promise<import("@granite-js/plugin-core").BuildSuccessResult[]>;
 export {};

package/dist/operations/build.js

@@ -38,7 +38,9 @@ var import_plugin_core = require("@granite-js/plugin-core");
 var import_es_toolkit = require("es-toolkit");
 var import_bundler = require("../bundler");
 var import_performance = require("../performance");
+var import_buildResult = require("../utils/buildResult");
 var import_getDefaultOutfileName = require("../utils/getDefaultOutfileName");
+var import_promise = require("../utils/promise");
 var import_writeBundle = require("../utils/writeBundle");
 async function build({ config, plugins = [], ...options }) {
   const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
@@ -48,21 +50,24 @@ async function build({ config, plugins = [], ...options }) {
   return buildResult;
 }
 async function buildAll(optionsList, { config, plugins = [], concurrency = 2 }) {
-  const buildResults = [];
   const semaphore = new import_es_toolkit.Semaphore(Math.min(concurrency, optionsList.length));
   const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
   await driver.build.pre();
-  await Promise.all(
+  const taskResults = await Promise.allSettled(
     optionsList.map(async (options) => {
       await semaphore.acquire();
       try {
         const buildResult = await buildImpl(config, plugins, options);
-        buildResults.push(buildResult);
-      } catch {
+        return buildResult;
+      } finally {
         semaphore.release();
       }
     })
   );
+  if (taskResults.some(import_promise.isRejected)) {
+    throw new Error("Build failed");
+  }
+  const buildResults = taskResults.filter(import_promise.isFulfilled).map((result) => result.value);
   await driver.build.post({ buildResults });
   return buildResults;
 }
@@ -85,13 +90,17 @@ async function buildImpl(config, plugins, { platform, outfile, cache = true, dev
     bundler.addPlugin(plugin());
   }
   const buildResult = await bundler.build();
-  await (0, import_writeBundle.writeBundle)(buildResult.outfile, buildResult.bundle);
-  const performanceSummary = import_performance.Performance.getSummary();
-  if (performanceSummary != null) {
-    (0, import_performance.printSummary)(performanceSummary);
-    await fs.writeFile(path.join(config.cwd, "perf.json"), JSON.stringify(performanceSummary, null, 2), "utf-8");
+  if ((0, import_buildResult.isBuildSuccess)(buildResult)) {
+    await (0, import_writeBundle.writeBundle)(buildResult.outfile, buildResult.bundle);
+    const performanceSummary = import_performance.Performance.getSummary();
+    if (performanceSummary != null) {
+      (0, import_performance.printSummary)(performanceSummary);
+      await fs.writeFile(path.join(config.cwd, "perf.json"), JSON.stringify(performanceSummary, null, 2), "utf-8");
+    }
+    return buildResult;
+  } else {
+    throw new Error("Build failed");
   }
-  return buildResult;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/plugins/statusPlugin.js

@@ -42,16 +42,17 @@ function statusPlugin(handlers) {
       handlers?.onStart?.();
     },
     buildEnd(result) {
-      progressBar.update(result.totalModuleCount);
-      progressBar.hide();
-      progressBar.remove();
-      if (result.errors.length === 0) {
+      if ("bundle" in result) {
         totalModuleCount = result.totalModuleCount;
         import_PersistentStorage.persistentStorage.setData({ [this.id]: { totalModuleCount: result.totalModuleCount } });
         import_PersistentStorage.persistentStorage.saveData();
-        handlers?.onEnd?.();
+      } else {
+        totalModuleCount = void 0;
       }
-      (0, import_es_toolkit.delay)(100).then(() => (0, import_printSummary.printSummary)(result));
+      progressBar.hide();
+      progressBar.remove();
+      handlers?.onEnd?.();
+      (0, import_es_toolkit.delay)(100).then(() => (0, import_printSummary.printSummary)(result)).catch(import_es_toolkit.noop);
     },
     load: (moduleCount) => {
       progressBar.update(moduleCount, totalModuleCount);

package/dist/server/DevServer.js

@@ -192,21 +192,25 @@ class DevServer {
   }
   async getBundle(platform) {
     const { bundler } = this.getContext()[platform];
-    const { bundle } = await bundler.build({ withDispose: false });
+    const buildResult = await bundler.build({ withDispose: false });
     let targetBundle;
-    if (globalThis.remoteBundles != null) {
-      const hostBundleContent = bundle.source.text;
-      const remoteBundleContent = globalThis.remoteBundles[platform];
-      const mergedBundle = await (0, import_mergeBundles.mergeBundles)({
-        platform,
-        hostBundleContent,
-        remoteBundleContent
-      });
-      targetBundle = mergedBundle;
+    if ("bundle" in buildResult) {
+      if (globalThis.remoteBundles != null) {
+        const hostBundleContent = buildResult.bundle.source.text;
+        const remoteBundleContent = globalThis.remoteBundles[platform];
+        const mergedBundle = await (0, import_mergeBundles.mergeBundles)({
+          platform,
+          hostBundleContent,
+          remoteBundleContent
+        });
+        targetBundle = mergedBundle;
+      } else {
+        targetBundle = buildResult.bundle;
+      }
+      return targetBundle;
     } else {
-      targetBundle = bundle;
+      throw new Error("Build failed");
     }
-    return targetBundle;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/buildResult.d.ts

@@ -0,0 +1,2 @@
+import type { BuildResult, BuildSuccessResult } from '@granite-js/plugin-core';
+export declare function isBuildSuccess(result: BuildResult): result is BuildSuccessResult;

package/dist/utils/buildResult.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildResult_exports = {};
+__export(buildResult_exports, {
+  isBuildSuccess: () => isBuildSuccess
+});
+module.exports = __toCommonJS(buildResult_exports);
+function isBuildSuccess(result) {
+  return "bundle" in result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBuildSuccess
+});

package/dist/utils/printSummary.d.ts

@@ -1,7 +1,2 @@
-import { Message } from 'esbuild';
-export declare function printSummary<Result extends {
-    warnings: Message[];
-    errors: Message[];
-    totalModuleCount: number;
-    duration: number;
-}>({ warnings, errors, totalModuleCount, duration }: Result): Promise<void>;
+import type { BuildResult } from '@granite-js/plugin-core';
+export declare function printSummary(buildResult: BuildResult): Promise<void>;

package/dist/utils/printSummary.js

@@ -32,22 +32,27 @@ __export(printSummary_exports, {
 });
 module.exports = __toCommonJS(printSummary_exports);
 var import_chalk = __toESM(require("chalk"));
+var import_es_toolkit = require("es-toolkit");
 var import_esbuild = require("esbuild");
 var import_logger = require("../logger");
-function printSummary({ warnings, errors, totalModuleCount, duration }) {
-  return Promise.all([(0, import_esbuild.formatMessages)(warnings, { kind: "warning" }), (0, import_esbuild.formatMessages)(errors, { kind: "error" })]).then(
-    ([warnings2, errors2]) => {
-      warnings2.forEach((message) => import_logger.logger.warn("\n\n", message));
-      errors2.forEach((message) => import_logger.logger.error("\n\n", message));
-      const durations = import_chalk.default.underline(`${totalModuleCount} Modules (${(duration / 1e3).toFixed(2)}s)`);
-      const summary = [
-        durations,
-        `${import_chalk.default.red(errors2.length)} errors`,
-        `${import_chalk.default.yellow(warnings2.length)} warnings`
-      ].join(import_chalk.default.white(" | "));
-      import_logger.logger.info(import_chalk.default.gray(summary));
-    }
-  );
+var import_buildResult = require("./buildResult");
+function printSummary(buildResult) {
+  return Promise.all([
+    (0, import_esbuild.formatMessages)(buildResult.warnings, { kind: "warning", color: true }),
+    (0, import_esbuild.formatMessages)(buildResult.errors, { kind: "error", color: true })
+  ]).then(([warnings, errors]) => {
+    warnings.forEach((message) => console.warn("\n\n", message));
+    errors.forEach((message) => console.error("\n\n", message));
+    const platform = `[${buildResult.platform}]`;
+    const moduleCountAndDuration = (0, import_buildResult.isBuildSuccess)(buildResult) ? import_chalk.default.underline(`${buildResult.totalModuleCount} Modules (${(buildResult.duration / 1e3).toFixed(2)}s)`) : null;
+    const summary = [
+      platform,
+      moduleCountAndDuration,
+      `${import_chalk.default.red(errors.length)} errors`,
+      `${import_chalk.default.yellow(warnings.length)} warnings`
+    ].filter(import_es_toolkit.isNotNil).join(import_chalk.default.white(" | "));
+    import_logger.logger.info(import_chalk.default.gray(summary));
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/utils/{promiseHandler.d.ts → promise.d.ts}

@@ -10,3 +10,5 @@ export declare class PromiseHandler<T> {
     done(result: T): void;
     abort(reason?: Error): void;
 }
+export declare function isFulfilled<T>(task: PromiseSettledResult<T>): task is PromiseFulfilledResult<T>;
+export declare function isRejected<T>(task: PromiseSettledResult<T>): task is PromiseRejectedResult;

package/dist/utils/{promiseHandler.js → promise.js}

@@ -16,11 +16,13 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var promiseHandler_exports = {};
-__export(promiseHandler_exports, {
-  PromiseHandler: () => PromiseHandler
+var promise_exports = {};
+__export(promise_exports, {
+  PromiseHandler: () => PromiseHandler,
+  isFulfilled: () => isFulfilled,
+  isRejected: () => isRejected
 });
-module.exports = __toCommonJS(promiseHandler_exports);
+module.exports = __toCommonJS(promise_exports);
 var import_es_toolkit = require("es-toolkit");
 class PromiseHandler {
   constructor(revisionId) {
@@ -48,7 +50,15 @@ class PromiseHandler {
     this.rejector(reason);
   }
 }
+function isFulfilled(task) {
+  return task.status === "fulfilled";
+}
+function isRejected(task) {
+  return task.status === "rejected";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PromiseHandler
+  PromiseHandler,
+  isFulfilled,
+  isRejected
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@granite-js/mpack",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "A bundler for Granite apps",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -83,9 +83,9 @@
     "@babel/traverse": "^7.14.0",
     "@babel/types": "^7.0.0",
     "@fastify/static": "7.0.1",
-    "@granite-js/devtools-frontend": "0.1.10",
-    "@granite-js/plugin-core": "0.1.10",
-    "@granite-js/utils": "0.1.10",
+    "@granite-js/devtools-frontend": "0.1.12",
+    "@granite-js/plugin-core": "0.1.12",
+    "@granite-js/utils": "0.1.12",
     "@inquirer/prompts": "^7.2.3",
     "@react-native-community/cli-plugin-metro": "11.3.7",
     "@react-native-community/cli-server-api": "11.3.7",

package/dist/bundler/plugins/dependencyAliasPlugin/aliasResolver.d.ts

@@ -1,3 +0,0 @@
-import type { AliasConfig } from '@granite-js/plugin-core';
-import type { PluginBuild } from 'esbuild';
-export declare function setupAliasResolver(build: PluginBuild, rootDir: string, aliasConfig: AliasConfig[]): void;

package/dist/bundler/plugins/dependencyAliasPlugin/aliasResolver.js

@@ -1,89 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var aliasResolver_exports = {};
-__export(aliasResolver_exports, {
-  setupAliasResolver: () => setupAliasResolver
-});
-module.exports = __toCommonJS(aliasResolver_exports);
-var import_path = __toESM(require("path"));
-var import_performance = require("../../../performance");
-var import_esbuildUtils = require("../../../utils/esbuildUtils");
-var import_replaceModulePath = require("../../../utils/replaceModulePath");
-var import_swc = require("../shared/swc");
-const resolved = Symbol();
-function setupAliasResolver(build, rootDir, aliasConfig) {
-  function aliasResolver(path2, options) {
-    return build.resolve(path2, {
-      ...options,
-      pluginData: {
-        ...options?.pluginData,
-        [resolved]: true
-      }
-    });
-  }
-  [import_swc.swcHelperOptimizationRules.getAliasConfig(), ...aliasConfig].forEach(({ from, to, exact }) => {
-    const resolveResultCache = /* @__PURE__ */ new Map();
-    const filter = new RegExp(exact ? `^${from}$` : `^${from}(?:$|/)`);
-    build.onResolve({ filter }, async (args) => {
-      if (args.pluginData?.[resolved]) {
-        return;
-      }
-      const trace = import_performance.Performance.trace("alias-resolver", {
-        detail: { pattern: filter, path: args.path }
-      });
-      const resolvedPath = typeof to === "string" ? (0, import_replaceModulePath.replaceModulePath)(args.path, from, to) : await to({ resolve: aliasResolver, args });
-      const normalizedPath = (0, import_esbuildUtils.normalizePath)(resolvedPath);
-      const cacheKey = `${args.kind}:${normalizedPath}`;
-      if (resolveResultCache.has(cacheKey)) {
-        trace.stop({ detail: { cacheHit: true } });
-        return resolveResultCache.get(cacheKey);
-      }
-      if (import_path.default.isAbsolute(normalizedPath)) {
-        trace.stop({ detail: { isAbsolute: true } });
-        const result2 = { path: normalizedPath };
-        resolveResultCache.set(cacheKey, result2);
-        return result2;
-      }
-      const result = await build.resolve(normalizedPath, {
-        resolveDir: rootDir,
-        kind: args.kind,
-        pluginData: {
-          [resolved]: true
-        }
-      });
-      trace.stop({ detail: { cacheHit: false, isAbsolute: false } });
-      resolveResultCache.set(cacheKey, result);
-      return result;
-    });
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  setupAliasResolver
-});

package/dist/bundler/plugins/dependencyAliasPlugin/dependencyAliasPlugin.d.ts

@@ -1,3 +0,0 @@
-import type { Plugin } from 'esbuild';
-import { PluginOptions } from '../types';
-export declare function dependencyAliasPlugin({ context }: PluginOptions): Plugin;

package/dist/bundler/plugins/dependencyAliasPlugin/index.d.ts

@@ -1 +0,0 @@
-export { dependencyAliasPlugin } from './dependencyAliasPlugin';