@dammers/use-signalr-core 1.0.0 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/calls.d.ts +9 -3
- package/dist/calls.js +39 -14
- package/dist/connection-manager.d.ts +4 -4
- package/dist/connection-manager.js +10 -3
- package/dist/context.d.ts +10 -1
- package/dist/session.d.ts +3 -3
- package/dist/session.js +59 -5
- package/dist/status-store.d.ts +1 -1
- package/dist/timers.d.ts +2 -0
- package/dist/timers.js +2 -0
- package/dist/types.d.ts +2 -2
- package/package.json +3 -3
package/README.md
CHANGED
|
@@ -23,7 +23,7 @@ This package is for adapter authors. To use SignalR in an app, install the adapt
|
|
|
23
23
|
npm install @dammers/use-signalr-core @microsoft/signalr
|
|
24
24
|
```
|
|
25
25
|
|
|
26
|
-
It needs `@microsoft/signalr` ^8 || ^9 || ^10 and Node 20.19 or later. It has no runtime dependencies.
|
|
26
|
+
It needs `@microsoft/signalr` ^8 || ^9 || ^10 || ^11 and Node 20.19 or later. It has no runtime dependencies.
|
|
27
27
|
|
|
28
28
|
## Documentation
|
|
29
29
|
|
package/dist/calls.d.ts
CHANGED
|
@@ -28,7 +28,7 @@ export interface InvokerOptions<T extends SignalRContract, H extends keyof T & H
|
|
|
28
28
|
method: M;
|
|
29
29
|
/** Called at call time. Returns the `InvokeOptions` for this call. */
|
|
30
30
|
getOptions: () => InvokeOptions | undefined;
|
|
31
|
-
/** Called at call time. Aborting the returned signal aborts
|
|
31
|
+
/** Called at call time. Aborting the returned signal aborts a call that still waits. A call that is already sent finishes. */
|
|
32
32
|
getSignal?: () => AbortSignal | undefined;
|
|
33
33
|
}
|
|
34
34
|
/** Builds the stable invoke function for one hub method. */
|
|
@@ -40,11 +40,17 @@ export declare function createSender<T extends SignalRContract, H extends keyof
|
|
|
40
40
|
method: M;
|
|
41
41
|
}): (...args: MethodArgs<T, H, M>) => Promise<boolean>;
|
|
42
42
|
/** Teardown sender. It acquires the hub itself, so it still works after its consumer is gone. */
|
|
43
|
-
export declare function createTeardownSender<T extends SignalRContract, H extends keyof T & HubString, M extends MethodName<T, H>>({ target: { acquire, release, waitForConnection }, hub, method, getOptions, }: {
|
|
43
|
+
export declare function createTeardownSender<T extends SignalRContract, H extends keyof T & HubString, M extends MethodName<T, H>>({ target: { acquire, release, waitForConnection, beginSend }, hub, method, getOptions, }: {
|
|
44
44
|
target: {
|
|
45
45
|
acquire: (hub: H) => void;
|
|
46
46
|
release: (hub: H) => void;
|
|
47
|
-
waitForConnection: (hub: H, timeoutMs: number) => Promise<HubConnection>;
|
|
47
|
+
waitForConnection: (hub: H, timeoutMs: number, signal?: AbortSignal) => Promise<HubConnection>;
|
|
48
|
+
/** Tells the session that a send is pending, so `stop()` can let it finish. Pass the one from the session context. */
|
|
49
|
+
beginSend?: (hub: H) => {
|
|
50
|
+
signal: AbortSignal;
|
|
51
|
+
use: (connection: HubConnection) => void;
|
|
52
|
+
end: () => void;
|
|
53
|
+
};
|
|
48
54
|
};
|
|
49
55
|
hub: H;
|
|
50
56
|
method: M;
|
package/dist/calls.js
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import { HubConnectionState } from "@microsoft/signalr";
|
|
2
2
|
import { isFinalWaitError } from "./errors.js";
|
|
3
|
+
import { MAX_TIMER_MS } from "./timers.js";
|
|
3
4
|
import { DEFAULT_BACKOFF, isRetriableInvokeError, resolveBackoff, sleep, } from "./retry.js";
|
|
4
5
|
const DEFAULT_TIMEOUT = 10000;
|
|
5
6
|
const DEFAULT_TEARDOWN_TIMEOUT = 10000;
|
|
@@ -67,23 +68,47 @@ export function createSender({ getConnection, hub, method, }) {
|
|
|
67
68
|
return connection.send(method, ...args).then(() => true, () => false);
|
|
68
69
|
};
|
|
69
70
|
}
|
|
71
|
+
function ignoreErrors(fn) {
|
|
72
|
+
try {
|
|
73
|
+
fn();
|
|
74
|
+
}
|
|
75
|
+
catch {
|
|
76
|
+
// Nothing is left to report to.
|
|
77
|
+
}
|
|
78
|
+
}
|
|
70
79
|
/** Teardown sender. It acquires the hub itself, so it still works after its consumer is gone. */
|
|
71
|
-
export function createTeardownSender({ target: { acquire, release, waitForConnection }, hub, method, getOptions, }) {
|
|
80
|
+
export function createTeardownSender({ target: { acquire, release, waitForConnection, beginSend }, hub, method, getOptions, }) {
|
|
72
81
|
return (...args) => {
|
|
73
82
|
const timeout = getOptions()?.timeout ?? DEFAULT_TEARDOWN_TIMEOUT;
|
|
83
|
+
const inFlight = beginSend?.(hub); // registered before any await, so a later stop() sees it
|
|
74
84
|
acquire(hub); // hold the hub open past our own unmount, until flushed
|
|
75
|
-
return
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
}
|
|
87
|
-
|
|
85
|
+
return new Promise((resolve) => {
|
|
86
|
+
let finished = false;
|
|
87
|
+
const finish = (sent) => {
|
|
88
|
+
if (finished)
|
|
89
|
+
return;
|
|
90
|
+
finished = true;
|
|
91
|
+
clearTimeout(timer);
|
|
92
|
+
resolve(sent);
|
|
93
|
+
// A failing cleanup must not leave the call pending or throw from a timer.
|
|
94
|
+
ignoreErrors(() => release(hub));
|
|
95
|
+
ignoreErrors(() => inFlight?.end());
|
|
96
|
+
};
|
|
97
|
+
// The timeout also covers the send, so a stuck send cannot hold a stopped connection open.
|
|
98
|
+
const timer = Number.isFinite(timeout)
|
|
99
|
+
? setTimeout(() => finish(false), Math.min(timeout, MAX_TIMER_MS))
|
|
100
|
+
: undefined;
|
|
101
|
+
void (async () => {
|
|
102
|
+
try {
|
|
103
|
+
const connection = await waitForConnection(hub, timeout, inFlight?.signal);
|
|
104
|
+
inFlight?.use(connection);
|
|
105
|
+
await connection.send(method, ...args);
|
|
106
|
+
finish(true);
|
|
107
|
+
}
|
|
108
|
+
catch {
|
|
109
|
+
finish(false); // never connected in time, the session stopped, or the send failed: best-effort
|
|
110
|
+
}
|
|
111
|
+
})();
|
|
112
|
+
});
|
|
88
113
|
};
|
|
89
114
|
}
|
|
@@ -21,15 +21,15 @@ export interface ConnectionManagerDeps<Hub extends HubString> {
|
|
|
21
21
|
onStatus: (hub: Hub, status: HubConnectionStatus, error?: unknown) => void;
|
|
22
22
|
/** Reports once per outage: the first failed attempt of a retriable outage, or a non-retriable error. */
|
|
23
23
|
onError: (hub: Hub, error: unknown, info: SignalRErrorInfo) => void;
|
|
24
|
-
/** True while this manager
|
|
24
|
+
/** True while this manager is the live one. Guards stale rebuilds. */
|
|
25
25
|
isCurrent: () => boolean;
|
|
26
26
|
}
|
|
27
27
|
export interface ConnectionManager<Hub extends HubString> {
|
|
28
28
|
/** Builds/starts desired hubs and stops undesired ones. Safe to call repeatedly. */
|
|
29
29
|
reconcile: () => void;
|
|
30
30
|
getConnection: (hub: Hub) => HubConnection | null;
|
|
31
|
-
/** Stops all connections and cancels timers. */
|
|
32
|
-
dispose: () =>
|
|
31
|
+
/** Stops all connections and cancels timers. A connected hub in `keep` stays open and is returned, so the caller closes it. */
|
|
32
|
+
dispose: (keep?: ReadonlySet<Hub>) => Map<Hub, HubConnection>;
|
|
33
33
|
}
|
|
34
|
-
/** Owns the hub connections of one provider
|
|
34
|
+
/** Owns the hub connections of one provider: build, start with recovery, lazy ref-counted stop. */
|
|
35
35
|
export declare function createConnectionManager<Hub extends HubString>(deps: ConnectionManagerDeps<Hub>): ConnectionManager<Hub>;
|
|
@@ -33,7 +33,7 @@ export function runUserCallback(hub, callback, onError) {
|
|
|
33
33
|
report(err);
|
|
34
34
|
}
|
|
35
35
|
}
|
|
36
|
-
/** Owns the hub connections of one provider
|
|
36
|
+
/** Owns the hub connections of one provider: build, start with recovery, lazy ref-counted stop. */
|
|
37
37
|
export function createConnectionManager(deps) {
|
|
38
38
|
const { baseUrl, hubs, resolve, getAccessToken, refCounts, stopTimers, reconnectListeners, connectedBefore, dispatch, onStatus, isCurrent, } = deps;
|
|
39
39
|
const report = (hub, error, source) => runUserCallback(hub, () => deps.onError(hub, error, { source }), noop);
|
|
@@ -267,7 +267,8 @@ export function createConnectionManager(deps) {
|
|
|
267
267
|
}
|
|
268
268
|
};
|
|
269
269
|
const getConnection = (hub) => built.get(hub)?.connection ?? null;
|
|
270
|
-
const dispose = () => {
|
|
270
|
+
const dispose = (keep) => {
|
|
271
|
+
const left = new Map();
|
|
271
272
|
disposing = true;
|
|
272
273
|
stopTimers.forEach((id) => clearTimeout(id));
|
|
273
274
|
stopTimers.clear();
|
|
@@ -275,8 +276,14 @@ export function createConnectionManager(deps) {
|
|
|
275
276
|
recoverTimers.clear();
|
|
276
277
|
attempts.clear();
|
|
277
278
|
misconfigured.clear();
|
|
278
|
-
built.forEach((e, hub) =>
|
|
279
|
+
built.forEach((e, hub) => {
|
|
280
|
+
if (keep?.has(hub) && e.connection.state === HubConnectionState.Connected)
|
|
281
|
+
left.set(hub, e.connection);
|
|
282
|
+
else
|
|
283
|
+
stopConnection(hub, e.connection);
|
|
284
|
+
});
|
|
279
285
|
// refCounts are kept across rebuilds on purpose.
|
|
286
|
+
return left;
|
|
280
287
|
};
|
|
281
288
|
return { reconcile, getConnection, dispose };
|
|
282
289
|
}
|
package/dist/context.d.ts
CHANGED
|
@@ -21,7 +21,7 @@ export interface SignalRProviderPropsBase<THub extends string = HubString> {
|
|
|
21
21
|
export interface SignalRPublicContext<T extends SignalRContract> {
|
|
22
22
|
/** The live `HubConnection` of the hub, or `null` when none exists. */
|
|
23
23
|
getConnection: (hub: keyof T & HubString) => HubConnection | null;
|
|
24
|
-
/**
|
|
24
|
+
/** One-time read of the hub's current status. In a reactive scope of a signal-based framework (Solid, Vue, Angular), the read tracks. */
|
|
25
25
|
getStatus: (hub: keyof T & HubString) => HubConnectionStatus;
|
|
26
26
|
/**
|
|
27
27
|
* Resolves once the hub is connected. Waits across stop, start, and rebuilds.
|
|
@@ -41,6 +41,15 @@ export interface SignalRContextValueBase<T extends SignalRContract, TStore> exte
|
|
|
41
41
|
acquire: (hub: keyof T & HubString) => void;
|
|
42
42
|
/** Lowers the lazy reference count of a hub. */
|
|
43
43
|
release: (hub: keyof T & HubString) => void;
|
|
44
|
+
/**
|
|
45
|
+
* Tells the session that a teardown send is pending on a hub. `stop()` then keeps that connection open until `end()`, so the send can finish.
|
|
46
|
+
* The signal aborts the wait for the connection when the session stops. Call `use(connection)` with the connection that carries the send, and `end()` once, when the send ends.
|
|
47
|
+
*/
|
|
48
|
+
beginSend: (hub: keyof T & HubString) => {
|
|
49
|
+
signal: AbortSignal;
|
|
50
|
+
use: (connection: HubConnection) => void;
|
|
51
|
+
end: () => void;
|
|
52
|
+
};
|
|
44
53
|
/** Registers a callback that runs after each reconnect, not after the first connect. Returns an unsubscribe function. */
|
|
45
54
|
registerReconnect: (hub: keyof T & HubString, cb: () => void) => () => void;
|
|
46
55
|
/** Registers an event handler. The handler survives rebuilds. Returns an unsubscribe function. */
|
package/dist/session.d.ts
CHANGED
|
@@ -31,14 +31,14 @@ export interface SignalRSessionValues {
|
|
|
31
31
|
connectionKey?: string | number;
|
|
32
32
|
}
|
|
33
33
|
export interface SignalRSession<T extends SignalRContract, TStore extends StatusStore<keyof T & HubString> = StatusStore<keyof T & HubString>> {
|
|
34
|
-
/**
|
|
34
|
+
/** Sets every hub to `"idle"`, closes the live connections, and forgets which hubs connected before. A connected hub with a pending teardown call stays open until the send ends. Calling it again leaves the hubs stopped. It also ends the waits of teardown calls that began after the first call. */
|
|
35
35
|
stop: () => void;
|
|
36
|
-
/** Does nothing if the values equal the last applied values. Otherwise it disposes the live
|
|
36
|
+
/** Does nothing if the values equal the last applied values. Otherwise it disposes the live connections and, if `enabled` is true and `baseUrl` is not empty, builds new ones. A rebuild keeps which hubs connected, so their reconnect callbacks run. */
|
|
37
37
|
update: (values: SignalRSessionValues) => void;
|
|
38
38
|
/** The value that an adapter puts into its framework context. Its identity is stable. */
|
|
39
39
|
context: SignalRContextValueBase<T, TStore>;
|
|
40
40
|
/** The frozen object with `getConnection`, `getStatus`, and `waitForConnection`. Its identity is stable. */
|
|
41
41
|
publicContext: SignalRPublicContext<T>;
|
|
42
42
|
}
|
|
43
|
-
/** Owns the
|
|
43
|
+
/** Owns the live connections, the lazy reference counts, the reconnect listeners, and the context value. Adapters add only framework binding. */
|
|
44
44
|
export declare function createSignalRSession<T extends SignalRContract, TStore extends StatusStore<keyof T & HubString> = StatusStore<keyof T & HubString>>(deps: SignalRSessionDeps<T, TStore>): SignalRSession<T, TStore>;
|
package/dist/session.js
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { HubConnectionState } from "@microsoft/signalr";
|
|
2
2
|
import { createConnectionManager, runUserCallback } from "./connection-manager.js";
|
|
3
3
|
import { SIGNALR_ERROR_NAMES, namedError } from "./errors.js";
|
|
4
|
-
|
|
5
|
-
/** Owns the
|
|
4
|
+
import { MAX_TIMER_MS } from "./timers.js";
|
|
5
|
+
/** Owns the live connections, the lazy reference counts, the reconnect listeners, and the context value. Adapters add only framework binding. */
|
|
6
6
|
export function createSignalRSession(deps) {
|
|
7
7
|
const { hubs, resolve, statusStore, getAccessToken, onStatusChange, onError } = deps;
|
|
8
8
|
const reportCallbackError = (hub, err) => onError?.(hub, err, { source: "callback" });
|
|
@@ -16,6 +16,8 @@ export function createSignalRSession(deps) {
|
|
|
16
16
|
const waiters = new Map();
|
|
17
17
|
// Hubs that stopped after a non-retriable error, with the error. A wait on one can never succeed.
|
|
18
18
|
const failed = new Map();
|
|
19
|
+
const pendingSends = new Map();
|
|
20
|
+
const heldConnections = new Set();
|
|
19
21
|
let disabled = false;
|
|
20
22
|
let current = null;
|
|
21
23
|
let applied = null;
|
|
@@ -118,7 +120,29 @@ export function createSignalRSession(deps) {
|
|
|
118
120
|
current = manager;
|
|
119
121
|
manager.reconcile(); // build eager hubs plus already-referenced lazy hubs
|
|
120
122
|
};
|
|
121
|
-
const
|
|
123
|
+
const closeHeldWithout = (send) => {
|
|
124
|
+
heldConnections.forEach((held) => {
|
|
125
|
+
held.sends.delete(send);
|
|
126
|
+
if (held.sends.size > 0)
|
|
127
|
+
return;
|
|
128
|
+
heldConnections.delete(held);
|
|
129
|
+
void held.connection.stop().catch((err) => runUserCallback(held.hub, () => onError?.(held.hub, err, { source: "connection" }), () => { }));
|
|
130
|
+
});
|
|
131
|
+
};
|
|
132
|
+
// A send that is not bound yet counts as bound to a connected hub: its wait has resolved, and `use()` runs a microtask later.
|
|
133
|
+
const sendsOnLiveConnections = () => {
|
|
134
|
+
const keep = new Map();
|
|
135
|
+
hubs.forEach((h) => {
|
|
136
|
+
const connection = current?.getConnection(h);
|
|
137
|
+
if (connection?.state !== HubConnectionState.Connected)
|
|
138
|
+
return;
|
|
139
|
+
const live = [...(pendingSends.get(h) ?? [])].filter((send) => send.connection === connection || send.connection === undefined);
|
|
140
|
+
if (live.length > 0)
|
|
141
|
+
keep.set(h, new Set(live));
|
|
142
|
+
});
|
|
143
|
+
return keep;
|
|
144
|
+
};
|
|
145
|
+
const teardown = (keepPendingSends = false) => {
|
|
122
146
|
// Publish before dispose, so listeners still see the live connection.
|
|
123
147
|
hubs.forEach((h) => {
|
|
124
148
|
const wasIdle = statusStore.get(h) === "idle";
|
|
@@ -127,7 +151,11 @@ export function createSignalRSession(deps) {
|
|
|
127
151
|
return;
|
|
128
152
|
runUserCallback(h, () => onStatusChange?.(h, "idle"), reportCallbackError);
|
|
129
153
|
});
|
|
130
|
-
|
|
154
|
+
// Read after the publish: a listener may begin a teardown during it.
|
|
155
|
+
const keep = keepPendingSends ? sendsOnLiveConnections() : undefined;
|
|
156
|
+
current
|
|
157
|
+
?.dispose(keep && new Set(keep.keys()))
|
|
158
|
+
.forEach((connection, hub) => heldConnections.add({ hub, connection, sends: new Set(keep?.get(hub)) }));
|
|
131
159
|
hubs.forEach((h) => {
|
|
132
160
|
if (resolve(h).lazy && !refCounts.get(h))
|
|
133
161
|
connectedBefore.delete(h); // a lazy hub with no consumer starts fresh
|
|
@@ -137,8 +165,9 @@ export function createSignalRSession(deps) {
|
|
|
137
165
|
failed.clear();
|
|
138
166
|
};
|
|
139
167
|
const stop = () => {
|
|
140
|
-
teardown();
|
|
168
|
+
teardown(true);
|
|
141
169
|
connectedBefore.clear();
|
|
170
|
+
pendingSends.forEach((set) => set.forEach((send) => send.controller.abort()));
|
|
142
171
|
};
|
|
143
172
|
const update = ({ baseUrl, enabled, connectionKey }) => {
|
|
144
173
|
const next = { baseUrl, enabled: enabled !== false, connectionKey };
|
|
@@ -180,6 +209,31 @@ export function createSignalRSession(deps) {
|
|
|
180
209
|
if (next === 0)
|
|
181
210
|
current?.reconcile();
|
|
182
211
|
},
|
|
212
|
+
beginSend: (hub) => {
|
|
213
|
+
const live = current?.getConnection(hub);
|
|
214
|
+
const send = {
|
|
215
|
+
controller: new AbortController(),
|
|
216
|
+
connection: live?.state === HubConnectionState.Connected ? live : undefined,
|
|
217
|
+
};
|
|
218
|
+
let set = pendingSends.get(hub);
|
|
219
|
+
if (!set)
|
|
220
|
+
pendingSends.set(hub, (set = new Set()));
|
|
221
|
+
set.add(send);
|
|
222
|
+
let ended = false;
|
|
223
|
+
return {
|
|
224
|
+
signal: send.controller.signal,
|
|
225
|
+
use: (connection) => {
|
|
226
|
+
send.connection = connection;
|
|
227
|
+
},
|
|
228
|
+
end: () => {
|
|
229
|
+
if (ended)
|
|
230
|
+
return;
|
|
231
|
+
ended = true;
|
|
232
|
+
set.delete(send);
|
|
233
|
+
closeHeldWithout(send);
|
|
234
|
+
},
|
|
235
|
+
};
|
|
236
|
+
},
|
|
183
237
|
registerReconnect: (hub, cb) => {
|
|
184
238
|
let set = reconnectListeners.get(hub);
|
|
185
239
|
if (!set)
|
package/dist/status-store.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import type { HubConnectionStatus } from "./types.js";
|
|
2
|
-
/** Per-hub status store:
|
|
2
|
+
/** Per-hub status store: one-time reads and writes keyed by hub. */
|
|
3
3
|
export interface StatusStore<H extends string> {
|
|
4
4
|
/** Returns the status of a hub. Must return `"idle"` for a hub without a value. */
|
|
5
5
|
get: (hub: H) => HubConnectionStatus;
|
package/dist/timers.d.ts
ADDED
package/dist/timers.js
ADDED
package/dist/types.d.ts
CHANGED
|
@@ -188,7 +188,7 @@ export interface InvokeOptions {
|
|
|
188
188
|
/** `true` retries, `false` throws at once, `undefined` uses the default rule. */
|
|
189
189
|
isRetriable?: (error: unknown) => boolean | undefined;
|
|
190
190
|
/**
|
|
191
|
-
* If `true`,
|
|
191
|
+
* If `true`, ending the consumer does not abort the wait or the retry delays, and the call holds a lazy hub open until it settles. If `false`, ending the consumer aborts them with an `AbortError`. A call that was already sent finishes in both cases.
|
|
192
192
|
* @default false
|
|
193
193
|
*/
|
|
194
194
|
keepAliveOnUnmount?: boolean;
|
|
@@ -196,7 +196,7 @@ export interface InvokeOptions {
|
|
|
196
196
|
/** Options for a teardown send. */
|
|
197
197
|
export interface TeardownOptions {
|
|
198
198
|
/**
|
|
199
|
-
* Maximum time in ms
|
|
199
|
+
* Maximum time in ms for the whole call: the wait for the hub to connect and the send. After that the library gives up and the call resolves `false`. A timeout above 2^31-1 ms counts as 2^31-1 ms. With a timeout that is not finite, the call has no time limit, and a send that never ends keeps its connection open.
|
|
200
200
|
* @default 10000
|
|
201
201
|
*/
|
|
202
202
|
timeout?: number;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dammers/use-signalr-core",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.1.0",
|
|
4
4
|
"description": "Framework-free typed multi-hub SignalR core: connection lifecycle, contracts, retry.",
|
|
5
5
|
"author": "Dammers",
|
|
6
6
|
"license": "MIT",
|
|
@@ -45,9 +45,9 @@
|
|
|
45
45
|
"test": "vitest run"
|
|
46
46
|
},
|
|
47
47
|
"peerDependencies": {
|
|
48
|
-
"@microsoft/signalr": "^8.0.0 || ^9.0.0 || ^10.0.0"
|
|
48
|
+
"@microsoft/signalr": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0"
|
|
49
49
|
},
|
|
50
50
|
"devDependencies": {
|
|
51
|
-
"@microsoft/signalr": "^8.0.0 || ^9.0.0 || ^10.0.0"
|
|
51
|
+
"@microsoft/signalr": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0"
|
|
52
52
|
}
|
|
53
53
|
}
|