@granite-js/mpack 0.0.1

package/dist/server/DevServer.js

@@ -0,0 +1,216 @@
+"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 DevServer_exports = {};
+__export(DevServer_exports, {
+  DevServer: () => DevServer
+});
+module.exports = __toCommonJS(DevServer_exports);
+var import_assert = __toESM(require("assert"));
+var fs = __toESM(require("fs/promises"));
+var import_fastify = __toESM(require("fastify"));
+var import_backend = require("react-native-devtools-standalone/backend");
+var import_DebuggerEventHandler = require("./debugger/DebuggerEventHandler");
+var import_createBundlerForDevServer = require("./helpers/createBundlerForDevServer");
+var import_mergeBundles = require("./helpers/mergeBundles");
+var import_middlewares = require("./middlewares");
+var serverPlugins = __toESM(require("./plugins"));
+var import_wss = require("./wss");
+var import_constants = require("../constants");
+var import_logger = require("../logger");
+var import_statusPlugin = require("../plugins/statusPlugin");
+var import_PersistentStorage = require("../shared/PersistentStorage");
+var import_isDebugMode = require("../utils/isDebugMode");
+var import_progressBar = require("../utils/progressBar");
+var import_dev_middleware = require("../vendors/@react-native/dev-middleware");
+var import_cli_server_api = require("../vendors/@react-native-community/cli-server-api");
+class DevServer {
+  constructor(devServerOptions) {
+    this.devServerOptions = devServerOptions;
+    import_logger.logger.trace("DevServer.constructor");
+    this.host = devServerOptions.host ?? import_constants.DEV_SERVER_DEFAULT_HOST;
+    this.port = devServerOptions.port ?? import_constants.DEV_SERVER_DEFAULT_PORT;
+    process.env.DEV_SERVER_HOST = String(this.host);
+    process.env.DEV_SERVER_PORT = String(this.port);
+    const app = (0, import_fastify.default)({
+      logger: {
+        level: (0, import_isDebugMode.isDebugMode)("mpack") ? "trace" : "silent"
+      }
+    });
+    this.app = app;
+    this.setup(app);
+  }
+  host;
+  port;
+  app;
+  context = null;
+  inspectorProxy;
+  wssDelegate;
+  async initialize() {
+    import_logger.logger.trace("DevServer.initialize");
+    const { rootDir, appName, scheme, ...devServerConfig } = this.devServerOptions;
+    await import_PersistentStorage.persistentStorage.loadData();
+    this.context = await this.createDevServerContext(rootDir, appName, scheme, devServerConfig);
+  }
+  listen() {
+    import_logger.logger.trace("DevServer.listen");
+    return this.app.listen({ host: this.host, port: this.port }).then(() => {
+      import_logger.logger.info(`\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589 \uC911 - ${this.getBaseUrl()}`);
+    });
+  }
+  close() {
+    return this.app.close();
+  }
+  getInspectorProxy() {
+    return this.inspectorProxy;
+  }
+  getBaseUrl() {
+    return `http://${this.host}:${this.port}`;
+  }
+  broadcastCommand(command) {
+    this.wssDelegate?.broadcastCommand?.(command);
+  }
+  getContext() {
+    (0, import_assert.default)(this.context, "\uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+    return this.context;
+  }
+  async setup(app) {
+    const baseRoot = this.devServerOptions.rootDir;
+    const serverBaseUrl = this.getBaseUrl();
+    const debuggerEventHandler = new import_DebuggerEventHandler.DebuggerEventHandler();
+    const inspectorProxy = new import_dev_middleware.InspectorProxy({ root: baseRoot, serverBaseUrl });
+    const inspectorProxyWss = inspectorProxy.createWebSocketServers({
+      onDeviceWebSocketConnected: (socket) => {
+        debuggerEventHandler.setDeviceWebSocketHandler(socket);
+      },
+      onDebuggerWebSocketConnected: (socket) => {
+        debuggerEventHandler.setDebuggerWebSocketHandler(socket);
+      }
+    });
+    const { debuggerProxySocket, eventsSocket, messageSocket } = (0, import_cli_server_api.createWebSocketEndpoints)({
+      broadcast: (command, params) => {
+        this.wssDelegate?.broadcastCommand(command, params);
+      }
+    });
+    const liveReloadMiddleware = (0, import_middlewares.createLiveReloadMiddleware)({
+      onClientLog: (event) => {
+        this.wssDelegate?.sendEvent(event);
+        if (event.type === "client_log") {
+          (0, import_logger.clientLogger)(event.level, event.data);
+        }
+      }
+    });
+    const wssDelegate = new import_wss.WebSocketServerDelegate({
+      eventReporter: (event) => eventsSocket.reportEvent(event),
+      messageBroadcaster: (command, params) => messageSocket.broadcast(command, params),
+      hmr: {
+        updateStart: () => liveReloadMiddleware.updateStart(),
+        updateDone: () => liveReloadMiddleware.updateDone(),
+        reload: () => liveReloadMiddleware.liveReload()
+      }
+    });
+    app.register(serverPlugins.statusPlugin, { rootDir: this.devServerOptions.rootDir }).register(serverPlugins.debuggerPlugin, { onReload: () => this.wssDelegate?.broadcastCommand("reload") }).register(serverPlugins.serveBundlePlugin, { getBundle: this.getBundle.bind(this) }).register(serverPlugins.symbolicatePlugin, { getBundle: this.getBundle.bind(this) }).register(serverPlugins.indexPagePlugin).addHook("onRequest", inspectorProxy.handleRequest).addHook("onSend", this.setCommonHeaders);
+    for (const plugin of this.devServerOptions.plugins ?? []) {
+      app.register(plugin);
+    }
+    new import_wss.WebSocketServerRouter().register("/hot", liveReloadMiddleware.server).register("/debugger-proxy", debuggerProxySocket.server).register("/message", messageSocket.server).register("/events", eventsSocket.server).register("/inspector/device", inspectorProxyWss.deviceSocketServer).register("/inspector/debug", inspectorProxyWss.debuggerSocketServer).setup(app);
+    await (0, import_backend.setupDevToolsProxy)({
+      client: {
+        delegate: {
+          onError: (error) => import_logger.logger.error("React DevTools client error", error)
+        }
+      },
+      devtools: {
+        delegate: {
+          onError: (error) => import_logger.logger.error("React DevTools frontend error", error)
+        }
+      }
+    });
+    this.inspectorProxy = inspectorProxy;
+    this.wssDelegate = wssDelegate;
+  }
+  setCommonHeaders(_request, reply, _payload, next) {
+    reply.header("Surrogate-Control", "no-store");
+    reply.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+    reply.header("Pragma", "no-cache");
+    reply.header("Expires", "0");
+    next();
+  }
+  async createDevServerContext(rootDir, appName, scheme, config) {
+    const [androidBundler, iosBundler] = await Promise.all([
+      (0, import_createBundlerForDevServer.createDevServerForDevServer)({ rootDir, appName, scheme, platform: "android", config }),
+      (0, import_createBundlerForDevServer.createDevServerForDevServer)({ rootDir, appName, scheme, platform: "ios", config })
+    ]);
+    [androidBundler, iosBundler].forEach((bundler) => {
+      bundler.addPlugin(
+        (0, import_statusPlugin.statusPlugin)({
+          onStart: () => {
+            this.wssDelegate?.onHMRUpdateStart();
+          },
+          onEnd: () => {
+            this.wssDelegate?.onHMRUpdateDone();
+            this.wssDelegate?.hotReload();
+          }
+        })
+      );
+    });
+    return {
+      config,
+      rootDir,
+      android: {
+        bundler: androidBundler,
+        progressBar: (0, import_progressBar.createProgressBar)(`${appName}:android`)
+      },
+      ios: {
+        bundler: iosBundler,
+        progressBar: (0, import_progressBar.createProgressBar)(`${appName}:ios`)
+      }
+    };
+  }
+  async getBundle(platform) {
+    const { bundler } = this.getContext()[platform];
+    const { bundle } = await bundler.build({ withDispose: false });
+    let targetBundle;
+    if (this.devServerOptions.preloadBundle != null) {
+      const sharedBundleContent = await fs.readFile(this.devServerOptions.preloadBundle, "utf-8");
+      const mergedBundle = await (0, import_mergeBundles.mergeBundles)({
+        platform,
+        preloadedBundleContent: sharedBundleContent,
+        mainBundle: bundle
+      });
+      targetBundle = mergedBundle;
+    } else {
+      targetBundle = bundle;
+    }
+    return targetBundle;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevServer
+});

package/dist/server/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEV_SERVER_BUNDLE_NAME = "index";

package/dist/server/constants.js

@@ -0,0 +1,28 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  DEV_SERVER_BUNDLE_NAME: () => DEV_SERVER_BUNDLE_NAME
+});
+module.exports = __toCommonJS(constants_exports);
+const DEV_SERVER_BUNDLE_NAME = "index";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEV_SERVER_BUNDLE_NAME
+});

package/dist/server/debugger/DebuggerEventHandler.d.ts

@@ -0,0 +1,41 @@
+import * as ws from 'ws';
+export declare class DebuggerEventHandler {
+    private networkResponseData;
+    setDeviceWebSocketHandler(socket: ws.WebSocket): void;
+    setDebuggerWebSocketHandler(socket: ws.WebSocket): void;
+    /**
+     * 네이티브로부터 전달받은 wrappedEvent가 커스텀 이벤트인 경우 파싱하여 반환
+     *
+     * ```js
+     * // message
+     * {
+     *   event: 'wrappedEvent',
+     *   payload: {
+     *     wrappedEvent: '<stringified event string>'
+     *   }
+     * }
+     *
+     * // wrappedEvent
+     * {
+     *   method: '<Namespace>.*',
+     *   params: {}
+     * }
+     * ```
+     */
+    private safetyParseCustomEvent;
+    /**
+     * Chrome Devtools Frontend 로부터 전달받은 CDP 이벤트 요청 데이터인 경우 파싱하여 반환
+     *
+     * ```js
+     * {
+     *   method: 'CDP Event',
+     *   params: {}
+     * }
+     * ```
+     */
+    private safetyParseDebuggerEvent;
+    private handleDeviceMessage;
+    private handleDebuggerMessage;
+    private handleNetworkResponseData;
+    private handleGetResponseBody;
+}

package/dist/server/debugger/DebuggerEventHandler.js

@@ -0,0 +1,169 @@
+"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 DebuggerEventHandler_exports = {};
+__export(DebuggerEventHandler_exports, {
+  DebuggerEventHandler: () => DebuggerEventHandler
+});
+module.exports = __toCommonJS(DebuggerEventHandler_exports);
+var import_debug = __toESM(require("debug"));
+var import_parseDomain = require("./parseDomain");
+const debug = (0, import_debug.default)("dev-server:debugger");
+class DebuggerEventHandler {
+  networkResponseData = /* @__PURE__ */ new Map();
+  setDeviceWebSocketHandler(socket) {
+    socket.on("message", (message) => this.handleDeviceMessage(socket, message));
+  }
+  setDebuggerWebSocketHandler(socket) {
+    socket.on("message", (message) => this.handleDebuggerMessage(socket, message));
+  }
+  /**
+   * 네이티브로부터 전달받은 wrappedEvent가 커스텀 이벤트인 경우 파싱하여 반환
+   *
+   * ```js
+   * // message
+   * {
+   *   event: 'wrappedEvent',
+   *   payload: {
+   *     wrappedEvent: '<stringified event string>'
+   *   }
+   * }
+   *
+   * // wrappedEvent
+   * {
+   *   method: '<Namespace>.*',
+   *   params: {}
+   * }
+   * ```
+   */
+  safetyParseCustomEvent(message) {
+    try {
+      const parsedMessage = JSON.parse(message.toString());
+      if (parsedMessage.event === "wrappedEvent") {
+        const wrappedEventPayload = JSON.parse(parsedMessage?.payload?.wrappedEvent);
+        const domain = (0, import_parseDomain.parseDomain)(wrappedEventPayload.method);
+        if (domain === "Bedrock" || domain === "Granite") {
+          return wrappedEventPayload;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Chrome Devtools Frontend 로부터 전달받은 CDP 이벤트 요청 데이터인 경우 파싱하여 반환
+   *
+   * ```js
+   * {
+   *   method: 'CDP Event',
+   *   params: {}
+   * }
+   * ```
+   */
+  safetyParseDebuggerEvent(message) {
+    try {
+      return JSON.parse(message.toString());
+    } catch {
+      return null;
+    }
+  }
+  handleDeviceMessage(_socket, message) {
+    const customEvent = this.safetyParseCustomEvent(message);
+    if (customEvent == null) {
+      return;
+    }
+    debug("handleDeviceMessage", customEvent);
+    switch (customEvent.method) {
+      case "Bedrock.networkResponseData":
+      case "Granite.networkResponseData":
+        this.handleNetworkResponseData(customEvent);
+        return;
+    }
+  }
+  handleDebuggerMessage(socket, message) {
+    let handled = true;
+    const debuggerEvent = this.safetyParseDebuggerEvent(message);
+    if (debuggerEvent == null) {
+      return;
+    }
+    switch (debuggerEvent.method) {
+      case "Network.getResponseBody":
+        this.handleGetResponseBody(socket, debuggerEvent);
+        break;
+      default:
+        handled = false;
+    }
+    if (handled) {
+      debug("handleDebuggerMessage", debuggerEvent);
+    }
+  }
+  handleNetworkResponseData(event) {
+    const { params } = event;
+    if (typeof params.requestId === "string") {
+      this.networkResponseData.set(params.requestId, {
+        data: params.data,
+        base64Encoded: params.base64Encoded
+      });
+    }
+  }
+  handleGetResponseBody(socket, event) {
+    const requestId = event.params.requestId.toString();
+    const responseData = this.networkResponseData.get(requestId);
+    if (responseData == null) {
+      return;
+    }
+    this.networkResponseData.delete(requestId);
+    let base64Encoded = responseData.base64Encoded;
+    let parsedOriginalData = null;
+    try {
+      parsedOriginalData = JSON.parse(responseData.base64Encoded ? atob(responseData.data) : responseData.data);
+      base64Encoded = false;
+    } catch {
+    }
+    debug("handleGetResponseBody", responseData);
+    socket.send(
+      JSON.stringify({
+        id: event.id,
+        result: {
+          /**
+           * JSON 파싱 시도하여 실제로 JSON 형태의 값인지 확인
+           *
+           * - 파싱 성공: 파싱된 데이터 전송
+           * - 파싱 실패: 기존 데이터 그대로 전송
+           */
+          body: typeof parsedOriginalData === "object" ? JSON.stringify(parsedOriginalData) : responseData.data,
+          base64Encoded
+        }
+      })
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebuggerEventHandler
+});

package/dist/server/debugger/parseDomain.d.ts

@@ -0,0 +1 @@
+export declare function parseDomain(method: string): string | undefined;

package/dist/server/debugger/parseDomain.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 parseDomain_exports = {};
+__export(parseDomain_exports, {
+  parseDomain: () => parseDomain
+});
+module.exports = __toCommonJS(parseDomain_exports);
+function parseDomain(method) {
+  return method.split(".")[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDomain
+});

package/dist/server/helpers/createBundlerForDevServer.d.ts

@@ -0,0 +1,10 @@
+import { Bundler } from '../../bundler';
+import { DevServerConfig } from '../../types';
+import { Platform } from '../types';
+export declare function createDevServerForDevServer({ rootDir, appName, scheme, platform, config, }: {
+    rootDir: string;
+    appName: string;
+    scheme: string;
+    platform: Platform;
+    config: DevServerConfig;
+}): Promise<Bundler>;

package/dist/server/helpers/createBundlerForDevServer.js

@@ -0,0 +1,75 @@
+"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 createBundlerForDevServer_exports = {};
+__export(createBundlerForDevServer_exports, {
+  createDevServerForDevServer: () => createDevServerForDevServer
+});
+module.exports = __toCommonJS(createBundlerForDevServer_exports);
+var import_bundler = require("../../bundler");
+var import_getBundleName = require("../../utils/getBundleName");
+var import_loadPresets = require("../../utils/loadPresets");
+var import_constants = require("../constants");
+async function createDevServerForDevServer({
+  rootDir,
+  appName,
+  scheme,
+  platform,
+  config
+}) {
+  const tag = "dev-server";
+  const dev = true;
+  const bundleName = (0, import_getBundleName.getBundleName)(import_constants.DEV_SERVER_BUNDLE_NAME);
+  const { build } = await (0, import_loadPresets.loadPresets)(
+    {
+      tag,
+      presets: config.presets,
+      build: {
+        ...config.build,
+        platform,
+        outfile: bundleName
+      }
+    },
+    {
+      rootDir,
+      appName,
+      scheme,
+      dev
+    }
+  );
+  const bundler = new import_bundler.Bundler({
+    tag,
+    rootDir,
+    appName,
+    scheme,
+    dev,
+    cache: true,
+    metafile: false,
+    buildConfig: build,
+    services: {
+      sentry: {
+        enabled: false
+      }
+    }
+  });
+  return bundler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServerForDevServer
+});

package/dist/server/helpers/mergeBundles.d.ts

@@ -0,0 +1,7 @@
+import { BundleData } from '../../bundler/types';
+import { Platform } from '../types';
+export declare function mergeBundles({ platform, preloadedBundleContent, mainBundle, }: {
+    platform: Platform;
+    preloadedBundleContent: string;
+    mainBundle: BundleData;
+}): Promise<BundleData>;