devframe 0.0.0 → 0.1.17

package/dist/recipes/open-helpers.mjs

@@ -0,0 +1,69 @@
+import { n as defineRpcFunction } from "../define-CW9gLnyG.mjs";
+import * as v from "valibot";
+//#region src/recipes/open-helpers.ts
+/**
+* Prebuilt RPC action that opens a file in the user's configured editor
+* via [`launch-editor`](https://www.npmjs.com/package/launch-editor).
+*
+* Registered name: `devframe:open-in-editor`.
+*
+* ```ts
+* import { openInEditor } from 'devframe/recipes/open-helpers'
+*
+* defineDevtool({
+*   id: 'my-tool',
+*   name: 'My Tool',
+*   setup(ctx) {
+*     ctx.rpc.register(openInEditor)
+*   },
+* })
+* ```
+*
+* Requires `launch-editor` to be installed by the consumer (declared as
+* an optional peer dependency on devframe).
+*/
+const openInEditor = defineRpcFunction({
+	name: "devframe:open-in-editor",
+	type: "action",
+	args: [v.string()],
+	returns: v.void(),
+	async handler(filename) {
+		const mod = await import("launch-editor");
+		(mod.default ?? mod)(filename);
+	}
+});
+/**
+* Prebuilt RPC action that reveals a path in the OS file explorer via
+* [`open`](https://www.npmjs.com/package/open).
+*
+* Registered name: `devframe:open-in-finder`.
+*
+* ```ts
+* import { openInFinder } from 'devframe/recipes/open-helpers'
+*
+* ctx.rpc.register(openInFinder)
+* ```
+*/
+const openInFinder = defineRpcFunction({
+	name: "devframe:open-in-finder",
+	type: "action",
+	args: [v.string()],
+	returns: v.void(),
+	async handler(path) {
+		const { default: open } = await import("../open-BMO2_-wC.mjs");
+		await open(path);
+	}
+});
+/**
+* Convenience array bundling both helpers so callers can register them
+* in a single `forEach`.
+*
+* ```ts
+* import { openHelpers } from 'devframe/recipes/open-helpers'
+*
+* openHelpers.forEach(fn => ctx.rpc.register(fn))
+* ```
+*/
+const openHelpers = [openInEditor, openInFinder];
+//#endregion
+export { openHelpers, openInEditor, openInFinder };

package/dist/rpc/client.d.mts

@@ -0,0 +1,9 @@
+import { BirpcOptions, BirpcReturn, ChannelOptions } from "birpc";
+
+//#region src/rpc/client.d.ts
+declare function createRpcClient<ServerFunctions extends object = Record<string, never>, ClientFunctions extends object = Record<string, never>>(functions: ClientFunctions, options: {
+  channel: ChannelOptions;
+  rpcOptions?: Partial<BirpcOptions<ServerFunctions, ClientFunctions, boolean>>;
+}): BirpcReturn<ServerFunctions, ClientFunctions, false>;
+//#endregion
+export { createRpcClient };

package/dist/rpc/client.mjs

@@ -0,0 +1,13 @@
+import { createBirpc } from "birpc";
+//#region src/rpc/client.ts
+function createRpcClient(functions, options) {
+	const { channel, rpcOptions = {} } = options;
+	return createBirpc(functions, {
+		...channel,
+		timeout: -1,
+		...rpcOptions,
+		proxify: false
+	});
+}
+//#endregion
+export { createRpcClient };

package/dist/rpc/index.d.mts

@@ -0,0 +1,3 @@
+import { _ as RpcCacheManager, a as structuredCloneDeserialize, c as structuredCloneStringify, d as createClientFromDump, f as dumpFunctions, g as RpcFunctionsCollectorBase, h as defineRpcFunction, i as strictJsonStringify, l as getRpcHandler, m as createDefineWrapperWithContext, n as validateDefinitions, o as structuredCloneParse, p as getDefinitionsWithDumps, r as STRUCTURED_CLONE_PREFIX, s as structuredCloneSerialize, t as validateDefinition, u as getRpcResolvedSetupResult, v as RpcCacheOptions } from "../index-Cei8vVcd.mjs";
+import { C as RpcReturnSchema, S as RpcFunctionsCollector, _ as RpcFunctionDefinitionAnyWithContext, a as RpcDefinitionsFilter, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcFunctionAgentOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionBase, w as Thenable, x as RpcFunctionType, y as RpcFunctionDefinitionToFunction } from "../types-BkyzI9r4.mjs";
+export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, Thenable, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -0,0 +1,4 @@
+import { a as validateDefinitions, c as getRpcResolvedSetupResult, i as validateDefinition, l as RpcCacheManager, n as dumpFunctions, o as RpcFunctionsCollectorBase, r as getDefinitionsWithDumps, s as getRpcHandler, t as createClientFromDump } from "../rpc-hbRk8qtt.mjs";
+import { a as structuredCloneSerialize, i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify, r as structuredCloneDeserialize, t as STRUCTURED_CLONE_PREFIX } from "../serialization-CWcWE7x7.mjs";
+import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-CW9gLnyG.mjs";
+export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify, validateDefinition, validateDefinitions };

package/dist/rpc/server.d.mts

@@ -0,0 +1,8 @@
+import { BirpcGroup, EventOptions } from "birpc";
+
+//#region src/rpc/server.d.ts
+declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options?: {
+  rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;
+}): BirpcGroup<ClientFunctions, ServerFunctions, false>;
+//#endregion
+export { createRpcServer };

package/dist/rpc/server.mjs

@@ -0,0 +1,10 @@
+import { createBirpcGroup } from "birpc";
+//#region src/rpc/server.ts
+function createRpcServer(functions, options = {}) {
+	return createBirpcGroup(functions, [], {
+		...options.rpcOptions,
+		proxify: false
+	});
+}
+//#endregion
+export { createRpcServer };

package/dist/rpc/transports/ws-client.d.mts

@@ -0,0 +1,2 @@
+import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-CDGmViwt.mjs";
+export { WsRpcChannelOptions, createWsRpcChannel };

package/dist/rpc/transports/ws-client.mjs

@@ -0,0 +1,58 @@
+import { i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify } from "../../serialization-CWcWE7x7.mjs";
+//#region src/rpc/transports/ws-client.ts
+function NOOP() {}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+/**
+* Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+* Pass the result straight to `createRpcClient`'s `channel` option.
+*/
+function createWsRpcChannel(options) {
+	let url = options.url;
+	if (options.authToken) url = `${url}?vite_devtools_auth_token=${encodeURIComponent(options.authToken)}`;
+	const ws = new WebSocket(url);
+	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
+	ws.addEventListener("open", (e) => {
+		onConnected(e);
+	});
+	ws.addEventListener("error", (e) => {
+		onError(e instanceof Error ? e : new Error(e.type));
+	});
+	ws.addEventListener("close", (e) => {
+		onDisconnected(e);
+	});
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
+	return {
+		on: (handler) => {
+			ws.addEventListener("message", (e) => {
+				handler(e.data);
+			});
+		},
+		post: (data) => {
+			if (ws.readyState === WebSocket.OPEN) ws.send(data);
+			else {
+				function handler() {
+					ws.send(data);
+					ws.removeEventListener("open", handler);
+				}
+				ws.addEventListener("open", handler);
+			}
+		},
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+			return `s:${structuredCloneStringify(msg)}`;
+		},
+		deserialize: (raw) => {
+			const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+			return msg;
+		}
+	};
+}
+//#endregion
+export { createWsRpcChannel };

package/dist/rpc/transports/ws-server.d.mts

@@ -0,0 +1,2 @@
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-Cu8tmZcF.mjs";
+export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

package/dist/rpc/transports/ws-server.mjs

@@ -0,0 +1,73 @@
+import { i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify } from "../../serialization-CWcWE7x7.mjs";
+import { createServer } from "node:https";
+import { WebSocketServer } from "ws";
+//#region src/rpc/transports/ws-server.ts
+let sessionId = 0;
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+function NOOP() {}
+/**
+* Attach a WebSocket transport to an existing RPC group. Either pass an
+* existing `WebSocketServer` via `wss`, or let this helper create one from
+* `port` / `host` / `https`.
+*/
+function attachWsRpcTransport(rpcGroup, options = {}) {
+	const { wss: externalWss, port, host = "localhost", https, onConnected = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS, serialize: serializeOverride, deserialize: deserializeOverride } = options;
+	let wss;
+	if (externalWss) wss = externalWss;
+	else if (https) {
+		const httpsServer = createServer(https);
+		wss = new WebSocketServer({ server: httpsServer });
+		httpsServer.listen(port, host);
+	} else wss = new WebSocketServer({
+		port,
+		host
+	});
+	wss.on("connection", (ws, req) => {
+		const meta = {
+			id: sessionId++,
+			ws,
+			subscribedStates: /* @__PURE__ */ new Set()
+		};
+		const pendingRequestMethods = /* @__PURE__ */ new Map();
+		const channel = {
+			post: (data) => {
+				ws.send(data);
+			},
+			on: (fn) => {
+				ws.on("message", (data) => {
+					fn(data.toString());
+				});
+			},
+			serialize: serializeOverride ?? ((msg) => {
+				let method;
+				if (msg.t === "q") method = msg.m;
+				else {
+					method = pendingRequestMethods.get(msg.i);
+					pendingRequestMethods.delete(msg.i);
+				}
+				if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+				return `s:${structuredCloneStringify(msg)}`;
+			}),
+			deserialize: deserializeOverride ?? ((raw) => {
+				const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+				if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+				return msg;
+			}),
+			meta
+		};
+		rpcGroup.updateChannels((channels) => {
+			channels.push(channel);
+		});
+		ws.on("close", () => {
+			rpcGroup.updateChannels((channels) => {
+				const index = channels.indexOf(channel);
+				if (index >= 0) channels.splice(index, 1);
+			});
+			onDisconnected(ws, meta);
+		});
+		onConnected(ws, req, meta);
+	});
+	return { wss };
+}
+//#endregion
+export { attachWsRpcTransport };