one
Version:
One is a new React Framework that makes Vite serve both native and web.
340 lines (338 loc) • 11 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf,
__hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: !0
});
},
__copyProps = (to, from, except, desc) => {
if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
}) : target, mod)),
__toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
value: !0
}), mod);
var ipc_exports = {};
__export(ipc_exports, {
cleanupSocket: () => cleanupSocket,
clearDaemonRoute: () => clearDaemonRoute,
createIPCServer: () => createIPCServer,
ensureSocketDir: () => ensureSocketDir,
getDaemonStatus: () => getDaemonStatus,
getLastActiveDaemonServer: () => getLastActiveDaemonServer,
getServersFilePath: () => getServersFilePath,
getSocketPath: () => getSocketPath,
isDaemonRunning: () => isDaemonRunning,
readServerFiles: () => readServerFiles,
registerWithDaemon: () => registerWithDaemon,
removeServerFile: () => removeServerFile,
sendIPCMessage: () => sendIPCMessage,
setDaemonRoute: () => setDaemonRoute,
touchDaemonServer: () => touchDaemonServer,
unregisterFromDaemon: () => unregisterFromDaemon,
writeServerFile: () => writeServerFile
});
module.exports = __toCommonJS(ipc_exports);
var net = __toESM(require("net"), 1),
fs = __toESM(require("fs"), 1),
path = __toESM(require("path"), 1),
os = __toESM(require("os"), 1),
import_registry = require("./registry.native.js");
function _instanceof(left, right) {
return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
}
var SOCKET_DIR = path.join(os.homedir(), ".one"),
SOCKET_PATH = path.join(SOCKET_DIR, "daemon.sock"),
SERVERS_FILE = path.join(SOCKET_DIR, "servers.json");
function getSocketPath() {
return SOCKET_PATH;
}
function getServersFilePath() {
return SERVERS_FILE;
}
function ensureSocketDir() {
fs.existsSync(SOCKET_DIR) || fs.mkdirSync(SOCKET_DIR, {
recursive: !0
});
}
function writeServerFile(server) {
ensureSocketDir();
var servers = readServerFiles(),
filtered = servers.filter(function (s) {
return s.root !== server.root;
});
filtered.push(server), fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function removeServerFile(root) {
var servers = readServerFiles(),
filtered = servers.filter(function (s) {
return s.root !== root;
});
fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function readServerFiles() {
try {
if (fs.existsSync(SERVERS_FILE)) return JSON.parse(fs.readFileSync(SERVERS_FILE, "utf-8"));
} catch {}
return [];
}
function cleanupSocket() {
try {
fs.existsSync(SOCKET_PATH) && fs.unlinkSync(SOCKET_PATH);
} catch {}
}
function createIPCServer(state, onServerRegistered, onServerUnregistered) {
ensureSocketDir(), cleanupSocket();
var server = net.createServer(function (socket) {
var buffer = "";
socket.on("data", function (data) {
buffer += data.toString();
var lines = buffer.split(`
`);
buffer = lines.pop() || "";
var _iteratorNormalCompletion = !0,
_didIteratorError = !1,
_iteratorError = void 0;
try {
for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
var line = _step.value;
if (line.trim()) try {
var message = JSON.parse(line),
response = handleMessage(state, message, onServerRegistered, onServerUnregistered);
socket.write(JSON.stringify(response) + `
`);
} catch (err) {
var errResponse = {
type: "error",
message: _instanceof(err, Error) ? err.message : "Unknown error"
};
socket.write(JSON.stringify(errResponse) + `
`);
}
}
} catch (err) {
_didIteratorError = !0, _iteratorError = err;
} finally {
try {
!_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
} finally {
if (_didIteratorError) throw _iteratorError;
}
}
}), socket.on("error", function (err) {
console.error("[daemon] IPC socket error:", err.message);
});
});
return server.listen(SOCKET_PATH, function () {
fs.chmodSync(SOCKET_PATH, 384);
}), server;
}
function handleMessage(state, message, onServerRegistered, onServerUnregistered) {
switch (message.type) {
case "register":
{
var registration = (0, import_registry.registerServer)(state, {
port: message.port,
bundleId: message.bundleId,
root: message.root
});
return onServerRegistered?.(registration.id), {
type: "registered",
id: registration.id
};
}
case "unregister":
return (0, import_registry.unregisterServer)(state, message.id), onServerUnregistered?.(message.id), {
type: "unregistered"
};
case "route":
{
var server = (0, import_registry.findServerById)(state, message.serverId);
return server ? ((0, import_registry.setRoute)(state, message.bundleId, message.serverId), {
type: "routed"
}) : {
type: "error",
message: `Server not found: ${message.serverId}`
};
}
case "route-clear":
return (0, import_registry.clearRoute)(state, message.bundleId), {
type: "routed"
};
case "status":
return {
type: "status",
servers: (0, import_registry.getAllServers)(state),
routes: (0, import_registry.getAllRoutes)(state)
};
case "ping":
return {
type: "pong"
};
case "touch":
{
var touched = (0, import_registry.touchServer)(state, message.id);
return touched ? {
type: "touched"
} : {
type: "error",
message: `Server not found: ${message.id}`
};
}
case "get-last-active":
{
var server1 = (0, import_registry.getLastActiveServer)(state);
return {
type: "last-active",
server: server1
};
}
default:
return {
type: "error",
message: "Unknown message type"
};
}
}
async function isDaemonRunning() {
return new Promise(function (resolve) {
if (!fs.existsSync(SOCKET_PATH)) {
resolve(!1);
return;
}
var client = net.connect(SOCKET_PATH),
timeout = setTimeout(function () {
client.destroy(), resolve(!1);
}, 1e3);
client.on("connect", function () {
clearTimeout(timeout), client.write(JSON.stringify({
type: "ping"
}) + `
`);
}), client.on("data", function (data) {
clearTimeout(timeout);
try {
var response = JSON.parse(data.toString().trim());
resolve(response.type === "pong");
} catch {
resolve(!1);
}
client.destroy();
}), client.on("error", function () {
clearTimeout(timeout), resolve(!1);
});
});
}
async function sendIPCMessage(message) {
return new Promise(function (resolve, reject) {
var client = net.connect(SOCKET_PATH),
buffer = "",
timeout = setTimeout(function () {
client.destroy(), reject(new Error("IPC timeout"));
}, 5e3);
client.on("connect", function () {
client.write(JSON.stringify(message) + `
`);
}), client.on("data", function (data) {
buffer += data.toString();
var lines = buffer.split(`
`);
buffer = lines.pop() || "";
var _iteratorNormalCompletion = !0,
_didIteratorError = !1,
_iteratorError = void 0;
try {
for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
var line = _step.value;
if (line.trim()) try {
clearTimeout(timeout);
var response = JSON.parse(line);
client.destroy(), resolve(response);
return;
} catch {}
}
} catch (err) {
_didIteratorError = !0, _iteratorError = err;
} finally {
try {
!_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
} finally {
if (_didIteratorError) throw _iteratorError;
}
}
}), client.on("error", function (err) {
clearTimeout(timeout), reject(err);
});
});
}
async function registerWithDaemon(opts) {
var response = await sendIPCMessage({
type: "register",
...opts
});
if (response.type === "registered") return response.id;
throw response.type === "error" ? new Error(response.message) : new Error("Unexpected response from daemon");
}
async function unregisterFromDaemon(id) {
await sendIPCMessage({
type: "unregister",
id
});
}
async function getDaemonStatus() {
var response = await sendIPCMessage({
type: "status"
});
if (response.type === "status") return {
servers: response.servers,
routes: response.routes
};
throw new Error("Failed to get daemon status");
}
async function setDaemonRoute(bundleId, serverId) {
var response = await sendIPCMessage({
type: "route",
bundleId,
serverId
});
if (response.type === "error") throw new Error(response.message);
}
async function clearDaemonRoute(bundleId) {
await sendIPCMessage({
type: "route-clear",
bundleId
});
}
async function touchDaemonServer(id) {
var response = await sendIPCMessage({
type: "touch",
id
});
if (response.type === "error") throw new Error(response.message);
}
async function getLastActiveDaemonServer() {
var response = await sendIPCMessage({
type: "get-last-active"
});
if (response.type === "last-active") return response.server;
throw new Error("Failed to get last active server");
}
//# sourceMappingURL=ipc.native.js.map