@granite-js/mpack 0.0.1

package/dist/server/helpers/mergeBundles.js

@@ -0,0 +1,129 @@
+"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 mergeBundles_exports = {};
+__export(mergeBundles_exports, {
+  mergeBundles: () => mergeBundles
+});
+module.exports = __toCommonJS(mergeBundles_exports);
+var esbuild = __toESM(require("esbuild"));
+var import_constants = require("../../constants");
+var import_getBundleName = require("../../utils/getBundleName");
+var import_getSourcemapName = require("../../utils/getSourcemapName");
+var import_constants2 = require("../constants");
+const INTERNAL_SOURCE = "mpack:internal";
+const IMPORT_SOURCE = "mpack:main-bundle";
+async function mergeBundles({
+  platform,
+  preloadedBundleContent,
+  mainBundle
+}) {
+  const bundleName = (0, import_getBundleName.getBundleName)(import_constants2.DEV_SERVER_BUNDLE_NAME);
+  const sourcemapName = (0, import_getSourcemapName.getSourcemapName)(bundleName);
+  const result = await esbuild.build({
+    logLevel: "silent",
+    stdin: {
+      contents: [`require('${INTERNAL_SOURCE}');`, preloadedBundleContent].join("\n"),
+      loader: "js"
+    },
+    outfile: bundleName,
+    bundle: true,
+    write: false,
+    minify: false,
+    treeShaking: false,
+    sourcemap: "external",
+    sourcesContent: true,
+    define: {
+      global: "window"
+    },
+    footer: {
+      /**
+       * 소스맵 옵션을 `external`로 지정하여 번들 코드 하단에 `#sourceMappingURL=path` 을 붙이지 않도록 하고,
+       * `footer` 옵션을 통해 개발 서버의 소스맵 주소(상대경로)로 매핑되도록 직접 추가함.
+       *
+       * - eg. `/index.bundle.map?platform=<platform>&dev=true`
+       *
+       * @see {@link https://esbuild.github.io/api/#sourcemap}
+       * @see {@link https://esbuild.github.io/api/#footer}
+       */
+      js: `//# sourceMappingURL=/${sourcemapName}?${new URLSearchParams({
+        platform,
+        dev: JSON.stringify(true)
+      }).toString()}`
+    },
+    plugins: [
+      {
+        name: "main-bundle-loader",
+        setup(build) {
+          build.onResolve({ filter: new RegExp(`^${INTERNAL_SOURCE}$`) }, () => ({
+            path: "dev-server-runtime",
+            namespace: "DEV_SERVER_RUNTIME"
+          }));
+          build.onResolve({ filter: new RegExp(`^${IMPORT_SOURCE}$`) }, () => ({
+            path: "main-bundle",
+            namespace: "MAIN_BUNDLE"
+          }));
+          build.onLoad({ filter: /.*/, namespace: "DEV_SERVER_RUNTIME" }, () => ({
+            contents: `
+            (function(global) {
+              global.${import_constants.INTERNAL_NAMESPACE_IDENTIFIER} = {};
+              global.${import_constants.INTERNAL_NAMESPACE_IDENTIFIER}.${import_constants.INTERNAL_EVALUATE_MAIN_BUNDLE_IDENTIFIER} = function INTERNAL__evaluateMainBundle() {
+                require('${IMPORT_SOURCE}');
+                return Promise.resolve();
+              }
+            })(
+              typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof global !== 'undefined'
+                  ? global
+                  : typeof window !== 'undefined'
+                    ? window
+                    : this
+            );
+            `,
+            loader: "js"
+          }));
+          build.onLoad({ filter: /.*/, namespace: "MAIN_BUNDLE" }, () => ({
+            contents: mainBundle.source.text,
+            loader: "js"
+          }));
+        }
+      }
+    ]
+  });
+  const sourceFile = result.outputFiles.find((file) => file.path.endsWith(bundleName));
+  const sourcemapFile = result.outputFiles.find((file) => file.path.endsWith(sourcemapName));
+  if (sourceFile && sourcemapFile) {
+    return { source: sourceFile, sourcemap: sourcemapFile };
+  }
+  throw new Error("failed to merge bundle");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeBundles
+});

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export * from './DevServer';

package/dist/server/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./DevServer"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./DevServer")
+});

package/dist/server/middlewares/createLiveReloadMiddleware.d.ts

@@ -0,0 +1,10 @@
+import * as ws from 'ws';
+import { ClientLogEvent } from '../types';
+export declare const createLiveReloadMiddleware: ({ onClientLog }: {
+    onClientLog?: (event: ClientLogEvent) => void;
+}) => {
+    server: ws.Server<typeof ws.WebSocket, typeof import("http").IncomingMessage>;
+    liveReload: () => void;
+    updateStart: () => void;
+    updateDone: () => void;
+};

package/dist/server/middlewares/createLiveReloadMiddleware.js

@@ -0,0 +1,129 @@
+"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 createLiveReloadMiddleware_exports = {};
+__export(createLiveReloadMiddleware_exports, {
+  createLiveReloadMiddleware: () => createLiveReloadMiddleware
+});
+module.exports = __toCommonJS(createLiveReloadMiddleware_exports);
+var ws = __toESM(require("ws"));
+var import_logger = require("../../logger");
+const getReloadByDevSettingsProxy = () => `(function () {
+  var moduleName = "DevSettings";
+  (window.__turboModuleProxy
+    ? window.__turboModuleProxy(moduleName)
+    : window.nativeModuleProxy[moduleName]).reload();
+})();`;
+const getMessage = (data) => {
+  try {
+    const parsedData = JSON.parse(String(data));
+    return "type" in parsedData ? parsedData : null;
+  } catch {
+    return null;
+  }
+};
+const createLiveReloadMiddleware = ({ onClientLog }) => {
+  const server = new ws.WebSocketServer({ noServer: true });
+  let connectedSocket = null;
+  const handleClose = () => {
+    connectedSocket = null;
+  };
+  const handleMessage = (event) => {
+    const message = getMessage(event.data);
+    if (!message) {
+      return;
+    }
+    switch (message.type) {
+      case "log": {
+        onClientLog?.({
+          type: "client_log",
+          level: message.level,
+          data: message.data,
+          mode: "BRIDGE"
+        });
+        break;
+      }
+      // Not supported
+      case "register-entrypoints":
+      case "log-opt-in":
+        break;
+    }
+  };
+  const handleError = (error) => {
+    if (error) {
+      import_logger.logger.error("HMR update \uBA54\uC2DC\uC9C0\uB97C \uC804\uC1A1\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4", error);
+    }
+  };
+  const liveReload = () => {
+    const hmrUpdateMessage = {
+      type: "update",
+      body: {
+        added: [
+          {
+            module: [-1, getReloadByDevSettingsProxy()],
+            sourceMappingURL: null,
+            sourceURL: null
+          }
+        ],
+        deleted: [],
+        modified: [],
+        isInitialUpdate: false,
+        revisionId: ""
+      }
+    };
+    connectedSocket?.send(JSON.stringify(hmrUpdateMessage), handleError);
+  };
+  const updateStart = () => {
+    const hmrUpdateStartMessage = {
+      type: "update-start",
+      body: {
+        isInitialUpdate: false
+      }
+    };
+    connectedSocket?.send(JSON.stringify(hmrUpdateStartMessage), handleError);
+  };
+  const updateDone = () => {
+    const hmrUpdateDoneMessage = { type: "update-done" };
+    connectedSocket?.send(JSON.stringify(hmrUpdateDoneMessage), handleError);
+  };
+  server.on("connection", (socket) => {
+    connectedSocket = socket;
+    connectedSocket.onerror = handleClose;
+    connectedSocket.onclose = handleClose;
+    connectedSocket.onmessage = handleMessage;
+    import_logger.logger.debug("HMR \uC6F9\uC18C\uCF13 \uC5F0\uACB0\uB428");
+  });
+  server.on("error", (error) => {
+    import_logger.logger.error("HMR \uC6F9\uC18C\uCF13 \uC11C\uBC84 \uC5D0\uB7EC", error);
+  });
+  return { server, liveReload, updateStart, updateDone };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLiveReloadMiddleware
+});

package/dist/server/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './createLiveReloadMiddleware';

package/dist/server/middlewares/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+module.exports = __toCommonJS(middlewares_exports);
+__reExport(middlewares_exports, require("./createLiveReloadMiddleware"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./createLiveReloadMiddleware")
+});

package/dist/server/plugins/debuggerPlugin.d.ts

@@ -0,0 +1,7 @@
+import { FastifyInstance } from 'fastify';
+interface DebuggerPluginConfig {
+    onReload: () => void;
+}
+declare function debuggerPluginImpl(app: FastifyInstance, config: DebuggerPluginConfig): Promise<void>;
+export declare const debuggerPlugin: typeof debuggerPluginImpl;
+export {};

package/dist/server/plugins/debuggerPlugin.js

@@ -0,0 +1,68 @@
+"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 debuggerPlugin_exports = {};
+__export(debuggerPlugin_exports, {
+  debuggerPlugin: () => debuggerPlugin
+});
+module.exports = __toCommonJS(debuggerPlugin_exports);
+var import_static = __toESM(require("@fastify/static"));
+var import_devtools_frontend = __toESM(require("@granite-js/devtools-frontend"));
+var import_fastify_plugin = __toESM(require("fastify-plugin"));
+var import_constants = require("../../constants");
+var import_logger = require("../../logger");
+async function debuggerPluginImpl(app, config) {
+  import_logger.logger.debug("debugger-plugin", { root: import_devtools_frontend.default, prefix: import_constants.DEBUGGER_FRONTEND_PATH });
+  app.register(import_static.default, {
+    root: import_devtools_frontend.default,
+    prefix: import_constants.DEBUGGER_FRONTEND_PATH
+  });
+  app.route({
+    method: ["GET", "POST"],
+    url: "/open-debugger",
+    handler: async (request, reply) => {
+      import_logger.logger.trace("open-debugger-plugin", { body: request.body });
+      reply.status(404);
+    }
+  }).route({
+    method: ["GET", "POST"],
+    url: "/reload",
+    handler: async (_request, reply) => {
+      import_logger.logger.trace("debugger-plugin");
+      config.onReload();
+      reply.status(200).send("OK");
+    }
+  });
+}
+const debuggerPlugin = (0, import_fastify_plugin.default)(debuggerPluginImpl, {
+  name: "debugger-plugin"
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debuggerPlugin
+});

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

@@ -0,0 +1,5 @@
+export * from './debuggerPlugin';
+export * from './indexPagePlugin';
+export * from './serveBundlePlugin';
+export * from './statusPlugin';
+export * from './symbolicatePlugin';

package/dist/server/plugins/index.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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./debuggerPlugin"), module.exports);
+__reExport(plugins_exports, require("./indexPagePlugin"), module.exports);
+__reExport(plugins_exports, require("./serveBundlePlugin"), module.exports);
+__reExport(plugins_exports, require("./statusPlugin"), module.exports);
+__reExport(plugins_exports, require("./symbolicatePlugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./debuggerPlugin"),
+  ...require("./indexPagePlugin"),
+  ...require("./serveBundlePlugin"),
+  ...require("./statusPlugin"),
+  ...require("./symbolicatePlugin")
+});

package/dist/server/plugins/indexPagePlugin.d.ts

@@ -0,0 +1,4 @@
+import { FastifyInstance } from 'fastify';
+declare function _indexPagePlugin(app: FastifyInstance): Promise<void>;
+export declare const indexPagePlugin: typeof _indexPagePlugin;
+export {};

package/dist/server/plugins/indexPagePlugin.js

@@ -0,0 +1,52 @@
+"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 indexPagePlugin_exports = {};
+__export(indexPagePlugin_exports, {
+  indexPagePlugin: () => indexPagePlugin
+});
+module.exports = __toCommonJS(indexPagePlugin_exports);
+var import_fastify_plugin = __toESM(require("fastify-plugin"));
+var import_logger = require("../../logger");
+async function _indexPagePlugin(app) {
+  app.route({
+    method: ["GET"],
+    url: "/",
+    handler: async (_request, reply) => {
+      import_logger.logger.trace("index-page-plugin");
+      reply.status(200).send("index page");
+    }
+  });
+}
+const indexPagePlugin = (0, import_fastify_plugin.default)(_indexPagePlugin, {
+  name: "index-page-plugin"
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  indexPagePlugin
+});

package/dist/server/plugins/reply.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyReply } from 'fastify';
+export declare function invalidRequest(reply: FastifyReply, logMessage: string): FastifyReply<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").RouteGenericInterface, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
+export declare function notFound(reply: FastifyReply, logMessage: string): FastifyReply<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").RouteGenericInterface, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;

package/dist/server/plugins/reply.js

@@ -0,0 +1,38 @@
+"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 reply_exports = {};
+__export(reply_exports, {
+  invalidRequest: () => invalidRequest,
+  notFound: () => notFound
+});
+module.exports = __toCommonJS(reply_exports);
+var import_Logger = require("../../logger/Logger");
+function invalidRequest(reply, logMessage) {
+  import_Logger.logger.warn(`invalid request: ${logMessage}`);
+  return reply.code(400);
+}
+function notFound(reply, logMessage) {
+  import_Logger.logger.warn(`not found: ${logMessage}`);
+  return reply.code(404);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  invalidRequest,
+  notFound
+});

package/dist/server/plugins/serveBundlePlugin.d.ts

@@ -0,0 +1,8 @@
+import { FastifyInstance } from 'fastify';
+import { BundleData } from '../../bundler/types';
+import type { Platform } from '../types';
+declare function _serveBundlePlugin(app: FastifyInstance, { getBundle }: {
+    getBundle: (platform: Platform) => Promise<BundleData>;
+}): Promise<void>;
+export declare const serveBundlePlugin: typeof _serveBundlePlugin;
+export {};

package/dist/server/plugins/serveBundlePlugin.js

@@ -0,0 +1,118 @@
+"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 serveBundlePlugin_exports = {};
+__export(serveBundlePlugin_exports, {
+  serveBundlePlugin: () => serveBundlePlugin
+});
+module.exports = __toCommonJS(serveBundlePlugin_exports);
+var import_path = __toESM(require("path"));
+var import_fastify_plugin = __toESM(require("fastify-plugin"));
+var import_reply = require("./reply");
+var import_logger = require("../../logger");
+var import_stripExtension = require("../../utils/stripExtension");
+var import_constants = require("../constants");
+var BundleResourceType = /* @__PURE__ */ ((BundleResourceType2) => {
+  BundleResourceType2["Bundle"] = "bundle";
+  BundleResourceType2["Sourcemap"] = "Sourcemap";
+  return BundleResourceType2;
+})(BundleResourceType || {});
+async function _serveBundlePlugin(app, { getBundle }) {
+  app.route({
+    method: ["GET"],
+    url: "/:file",
+    schema: {
+      querystring: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string"
+          },
+          app: {
+            type: "string"
+          },
+          dev: {
+            type: "boolean"
+          },
+          minify: {
+            type: "boolean"
+          },
+          runModule: {
+            type: "boolean"
+          },
+          inlineSourceMap: {
+            type: "boolean"
+          },
+          modulesOnly: {
+            type: "boolean"
+          }
+        },
+        required: ["platform"]
+      }
+    },
+    handler: async (request, reply) => {
+      const { file } = request.params;
+      const query = request.query;
+      const { platform } = query;
+      import_logger.logger.trace("serve-bundle-plugin", query);
+      if (file == null) {
+        return (0, import_reply.invalidRequest)(reply, "file is required");
+      }
+      const bundleResourceType = file.endsWith(".bundle") ? "bundle" /* Bundle */ : file.endsWith(".map") ? "Sourcemap" /* Sourcemap */ : null;
+      const isInvalidResourceType = bundleResourceType == null;
+      const isInvalidPlatform = !(platform === "android" || platform === "ios");
+      if (isInvalidResourceType || isInvalidPlatform) {
+        return (0, import_reply.invalidRequest)(reply, JSON.stringify({ isInvalidResourceType, platform }));
+      }
+      if (!(platform === "android" || platform === "ios")) {
+        return (0, import_reply.invalidRequest)(reply, "invalid platform");
+      }
+      const { name } = import_path.default.parse(file);
+      if ((0, import_stripExtension.stripExtension)(name) !== import_constants.DEV_SERVER_BUNDLE_NAME) {
+        return (0, import_reply.notFound)(reply, `invalid bundle name: ${name}`);
+      }
+      const bundle = await getBundle(platform);
+      switch (bundleResourceType) {
+        case "bundle" /* Bundle */:
+          return reply.headers({
+            "Content-Type": "application/javascript; charset=UTF-8"
+            // TODO: Custom header injection
+          }).status(200).send(Buffer.from(bundle.source.contents).toString("utf-8"));
+        case "Sourcemap" /* Sourcemap */:
+          return reply.header("Access-Control-Allow-Origin", "devtools://devtools").status(200).send(Buffer.from(bundle.sourcemap.contents).toString("utf-8"));
+      }
+    }
+  });
+}
+const serveBundlePlugin = (0, import_fastify_plugin.default)(_serveBundlePlugin, {
+  name: "serve-bundle-plugin"
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveBundlePlugin
+});