one/dist/cjs/daemon/picker.native.js

One is a new React Framework that makes Vite serve both native and web.

"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 picker_exports = {};
__export(picker_exports, {
  getBootedSimulators: () => getBootedSimulators,
  pickServer: () => pickServer,
  resolvePendingPicker: () => resolvePendingPicker,
  showPicker: () => showPicker
});
module.exports = __toCommonJS(picker_exports);
var import_child_process = require("child_process");
var import_util = require("util");
var readline = __toESM(require("readline"), 1);
var execAsync = (0, import_util.promisify)(import_child_process.exec);
var activePickerContext = null;
var rl = null;
var stdinDataListener = null;
async function getBootedSimulators() {
  try {
    var {
      stdout
    } = await execAsync("xcrun simctl list devices booted -j");
    var data = JSON.parse(stdout);
    var simulators = [];
    var _iteratorNormalCompletion = true,
      _didIteratorError = false,
      _iteratorError = void 0;
    try {
      for (var _iterator = Object.entries(data.devices || {})[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var [runtime, devices] = _step.value;
        var versionMatch = runtime.match(/iOS-(\d+)-(\d+)/);
        var iosVersion = versionMatch ? `${versionMatch[1]}.${versionMatch[2]}` : void 0;
        var _iteratorNormalCompletion1 = true,
          _didIteratorError1 = false,
          _iteratorError1 = void 0;
        try {
          for (var _iterator1 = devices[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
            var device = _step1.value;
            if (device.state === "Booted") {
              simulators.push({
                name: device.name,
                udid: device.udid,
                state: device.state,
                iosVersion
              });
            }
          }
        } catch (err) {
          _didIteratorError1 = true;
          _iteratorError1 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
              _iterator1.return();
            }
          } finally {
            if (_didIteratorError1) {
              throw _iteratorError1;
            }
          }
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
    return simulators;
  } catch (unused) {
    return [];
  }
}
async function showMacOSDialog(bundleId, servers) {
  if (process.platform !== "darwin") {
    return null;
  }
  var simulators = await getBootedSimulators();
  var simInfo = "";
  if (simulators.length > 0) {
    var seen = /* @__PURE__ */new Set();
    var uniqueSims = [];
    var _iteratorNormalCompletion = true,
      _didIteratorError = false,
      _iteratorError = void 0;
    try {
      for (var _iterator = simulators[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var sim = _step.value;
        var key = `${sim.name}-${sim.iosVersion || ""}`;
        if (!seen.has(key)) {
          seen.add(key);
          uniqueSims.push(sim.iosVersion ? `${sim.name} (iOS ${sim.iosVersion})` : sim.name);
        }
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
    if (uniqueSims.length === 1) {
      simInfo = `\\n\\nFrom: ${uniqueSims[0]}`;
    } else {
      simInfo = `\\n\\nActive simulators: ${uniqueSims.slice(0, 3).join(", ")}${uniqueSims.length > 3 ? "..." : ""}`;
    }
  }
  var choices = servers.map(function (s, i) {
    var shortRoot = s.root.replace(process.env.HOME || "", "~");
    return `${i + 1}. ${shortRoot} (port ${s.port})`;
  });
  var choicesStr = choices.map(function (c) {
    return `"${c.replace(/"/g, '\\"')}"`;
  }).join(", ");
  var prompt = `${bundleId} bundle requested${simInfo}\\n\\nWhich project should serve it?`;
  var script = `choose from list {${choicesStr}} with title "one daemon" with prompt "${prompt}" default items {"${choices[0].replace(/"/g, '\\"')}"}`;
  try {
    var {
      stdout
    } = await execAsync(`osascript -e '${script}'`);
    var result = stdout.trim();
    if (result === "false" || !result) {
      return null;
    }
    var match = result.match(/^(\d+)\./);
    if (match) {
      var index = parseInt(match[1], 10) - 1;
      if (index >= 0 && index < servers.length) {
        return {
          server: servers[index],
          remember: false
        };
      }
    }
    return null;
  } catch (unused) {
    return null;
  }
}
function showPicker(context) {
  activePickerContext = context;
  if (process.platform === "darwin") {
    showMacOSDialog(context.bundleId, context.servers).then(function (result) {
      if (result) {
        cleanupPicker();
        context.onSelect(result.server, result.remember);
      } else if (activePickerContext === context) {
        showTerminalPicker(context);
      }
    });
    return;
  }
  showTerminalPicker(context);
}
function showTerminalPicker(context) {
  console.log("\n" + "\u2500".repeat(60));
  console.log(`\u{1F500} ${context.bundleId} bundle requested`);
  console.log("\u2500".repeat(60));
  getBootedSimulators().then(function (sims) {
    if (sims.length > 0) {
      var seen = /* @__PURE__ */new Set();
      var uniqueSims = [];
      var _iteratorNormalCompletion = true,
        _didIteratorError = false,
        _iteratorError = void 0;
      try {
        for (var _iterator = sims[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var sim = _step.value;
          var key = `${sim.name}-${sim.iosVersion || ""}`;
          if (!seen.has(key)) {
            seen.add(key);
            uniqueSims.push(sim);
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
      if (uniqueSims.length === 1) {
        var sim1 = uniqueSims[0];
        console.log(`
From: ${sim1.name}${sim1.iosVersion ? ` (iOS ${sim1.iosVersion})` : ""}`);
      } else {
        console.log("\nActive simulators:");
        var _iteratorNormalCompletion1 = true,
          _didIteratorError1 = false,
          _iteratorError1 = void 0;
        try {
          for (var _iterator1 = uniqueSims.slice(0, 5)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
            var sim2 = _step1.value;
            console.log(`  \u2022 ${sim2.name}${sim2.iosVersion ? ` (iOS ${sim2.iosVersion})` : ""}`);
          }
        } catch (err) {
          _didIteratorError1 = true;
          _iteratorError1 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
              _iterator1.return();
            }
          } finally {
            if (_didIteratorError1) {
              throw _iteratorError1;
            }
          }
        }
      }
    }
  });
  console.log("\nWhich project should serve it?");
  context.servers.forEach(function (server, i) {
    var shortRoot = server.root.replace(process.env.HOME || "", "~");
    console.log(`  [${i + 1}] ${shortRoot} (port ${server.port})`);
  });
  console.log("\nPress 1-" + context.servers.length + " to select");
  console.log("Or 'r' + number to remember (e.g., 'r1')");
  console.log("Press 'c' to cancel\n");
  setupKeyboardInput();
}
function setupKeyboardInput() {
  if (rl) return;
  rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  if (process.stdin.isTTY) {
    process.stdin.setRawMode(true);
  }
  process.stdin.resume();
  var buffer = "";
  stdinDataListener = function (key) {
    var str = key.toString();
    if (str === "") {
      cancelPicker();
      return;
    }
    if (str === "\x1B") {
      cancelPicker();
      return;
    }
    if (str === "\x7F") {
      buffer = buffer.slice(0, -1);
      return;
    }
    if (str === "\r" || str === "\n") {
      processInput(buffer);
      buffer = "";
      return;
    }
    buffer += str;
    if (buffer.length === 1 && /^[1-9]$/.test(buffer)) {
      processInput(buffer);
      buffer = "";
    } else if (buffer.length === 2 && /^r[1-9]$/i.test(buffer)) {
      processInput(buffer);
      buffer = "";
    } else if (buffer.toLowerCase() === "c") {
      cancelPicker();
      buffer = "";
    }
  };
  process.stdin.on("data", stdinDataListener);
  var signalHandler = function () {
    cleanupPicker();
    process.exit(0);
  };
  process.on("SIGINT", signalHandler);
  process.on("SIGTERM", signalHandler);
}
function processInput(input) {
  if (!activePickerContext) return;
  var remember = input.toLowerCase().startsWith("r");
  var numStr = remember ? input.slice(1) : input;
  var num = parseInt(numStr, 10);
  if (isNaN(num) || num < 1 || num > activePickerContext.servers.length) {
    console.log(`Invalid selection: ${input}`);
    return;
  }
  var server = activePickerContext.servers[num - 1];
  var context = activePickerContext;
  cleanupPicker();
  context.onSelect(server, remember);
}
function cancelPicker() {
  var context = activePickerContext;
  cleanupPicker();
  if (context) {
    context.onCancel();
  }
}
function cleanupPicker() {
  activePickerContext = null;
  if (stdinDataListener) {
    process.stdin.removeListener("data", stdinDataListener);
    stdinDataListener = null;
  }
  if (rl) {
    rl.close();
    rl = null;
  }
  if (process.stdin.isTTY) {
    process.stdin.setRawMode(false);
  }
}
var pendingPickerResolvers = /* @__PURE__ */new Map();
function resolvePendingPicker(bundleId, serverId) {
  var resolver = pendingPickerResolvers.get(bundleId);
  if (!resolver || !activePickerContext) return false;
  var server = activePickerContext.servers.find(function (s) {
    return s.id === serverId;
  });
  if (!server) return false;
  pendingPickerResolvers.delete(bundleId);
  cleanupPicker();
  resolver.resolve(server);
  return true;
}
function pickServer(bundleId, servers) {
  return new Promise(function (resolve, reject) {
    pendingPickerResolvers.set(bundleId, {
      resolve: function (server) {
        return resolve({
          server,
          remember: false
        });
      },
      reject
    });
    showPicker({
      bundleId,
      servers,
      onSelect: function (server, remember) {
        pendingPickerResolvers.delete(bundleId);
        resolve({
          server,
          remember
        });
      },
      onCancel: function () {
        pendingPickerResolvers.delete(bundleId);
        reject(new Error("Selection cancelled"));
      }
    });
  });
}
//# sourceMappingURL=picker.native.js.map