devframe 0.0.0 → 0.1.16

package/dist/recipes/open-helpers.mjs

@@ -0,0 +1,69 @@
+import { n as defineRpcFunction } from "../define-Bb4zh-Dc.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-BtOOEldu.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,2 @@
+import { A as RpcFunctionSetupResult, C as RpcDumpStore, D as RpcFunctionDefinitionAnyWithContext, E as RpcFunctionDefinitionAny, F as RpcCacheManager, I as RpcCacheOptions, M as RpcFunctionsCollector, N as RpcReturnSchema, O as RpcFunctionDefinitionBase, P as Thenable, S as RpcDumpRecord, T as RpcFunctionDefinition, _ as RpcDump, a as createClientFromDump, b as RpcDumpDefinition, c as createDefineWrapperWithContext, d as BirpcFn, f as BirpcReturn, g as RpcDefinitionsToFunctions, h as RpcDefinitionsFilter, i as getRpcResolvedSetupResult, j as RpcFunctionType, k as RpcFunctionDefinitionToFunction, l as defineRpcFunction, m as RpcArgsSchema, n as validateDefinitions, o as dumpFunctions, p as EntriesToObject, r as getRpcHandler, s as getDefinitionsWithDumps, t as validateDefinition, u as RpcFunctionsCollectorBase, v as RpcDumpClientOptions, w as RpcFunctionAgentOptions, x as RpcDumpGetter, y as RpcDumpCollectionOptions } from "../index-DvKDO5H8.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, Thenable, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -0,0 +1,3 @@
+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-9FNa3Inb.mjs";
+import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-Bb4zh-Dc.mjs";
+export { RpcCacheManager, RpcFunctionsCollectorBase, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, 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-CklfxUHE.mjs";
+export { WsRpcChannelOptions, createWsRpcChannel };

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

@@ -0,0 +1,43 @@
+import { parse, stringify } from "structured-clone-es";
+//#region src/rpc/transports/ws-client.ts
+function NOOP() {}
+/**
+* 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 } = 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);
+	});
+	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: stringify,
+		deserialize: parse
+	};
+}
+//#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--IuUAaGi.mjs";
+export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

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

@@ -0,0 +1,58 @@
+import { parse, stringify } from "structured-clone-es";
+import { createServer } from "node:https";
+import { WebSocketServer } from "ws";
+//#region src/rpc/transports/ws-server.ts
+let sessionId = 0;
+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, serialize = stringify, deserialize = parse } = 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 channel = {
+			post: (data) => {
+				ws.send(data);
+			},
+			on: (fn) => {
+				ws.on("message", (data) => {
+					fn(data.toString());
+				});
+			},
+			serialize,
+			deserialize,
+			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 };