@camera.ui/rpc 1.0.3 → 1.0.4

package/externals/nats.js/core/src/options.ts

@@ -0,0 +1,202 @@
+/*
+ * Copyright 2021-2023 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { extend } from "./util.ts";
+import { defaultPort, getResolveFn } from "./transport.ts";
+import type { Authenticator, ConnectionOptions, ServerInfo } from "./core.ts";
+import { createInbox, DEFAULT_HOST } from "./core.ts";
+import {
+  multiAuthenticator,
+  noAuthFn,
+  tokenAuthenticator,
+  usernamePasswordAuthenticator,
+} from "./authenticator.ts";
+import { errors, InvalidArgumentError } from "./errors.ts";
+
+export const DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+export const DEFAULT_JITTER = 100;
+export const DEFAULT_JITTER_TLS = 1000;
+// Ping interval
+export const DEFAULT_PING_INTERVAL = 2 * 60 * 1000; // 2 minutes
+export const DEFAULT_MAX_PING_OUT = 2;
+export const DEFAULT_PING_TIMEOUT = 0;
+
+// DISCONNECT Parameters, 2 sec wait, 10 tries
+export const DEFAULT_RECONNECT_TIME_WAIT = 2 * 1000;
+// Upper bound for exponential reconnect-delay backoff. 0 = disabled (legacy
+// linear behavior).
+export const DEFAULT_RECONNECTION_DELAY_MAX = 0;
+// Multiplicative jitter factor [0..1] applied to the computed delay. 0 = no
+// multiplicative jitter (legacy `reconnectJitter` additive jitter still applies).
+export const DEFAULT_RECONNECTION_RANDOMIZATION_FACTOR = 0;
+
+export function defaultOptions(): ConnectionOptions {
+  return {
+    maxPingOut: DEFAULT_MAX_PING_OUT,
+    maxReconnectAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
+    noRandomize: false,
+    pedantic: false,
+    pingInterval: DEFAULT_PING_INTERVAL,
+    reconnect: true,
+    reconnectJitter: DEFAULT_JITTER,
+    reconnectJitterTLS: DEFAULT_JITTER_TLS,
+    reconnectTimeWait: DEFAULT_RECONNECT_TIME_WAIT,
+    tls: undefined,
+    verbose: false,
+    waitOnFirstConnect: false,
+    ignoreAuthErrorAbort: false,
+  } as ConnectionOptions;
+}
+
+export function hasWsProtocol(opts?: ConnectionOptions): boolean {
+  if (opts) {
+    let { servers } = opts;
+    if (typeof servers === "string") {
+      servers = [servers];
+    }
+    if (servers) {
+      for (let i = 0; i < servers.length; i++) {
+        const s = servers[i].toLowerCase();
+        if (s.startsWith("ws://") || s.startsWith("wss://")) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+export function buildAuthenticator(
+  opts: ConnectionOptions,
+): Authenticator {
+  const buf: Authenticator[] = [];
+  // jwtAuthenticator is created by the user, since it
+  // will require possibly reading files which
+  // some of the clients are simply unable to do
+  if (typeof opts.authenticator === "function") {
+    buf.push(opts.authenticator);
+  }
+  if (Array.isArray(opts.authenticator)) {
+    buf.push(...opts.authenticator);
+  }
+  if (opts.token) {
+    buf.push(tokenAuthenticator(opts.token));
+  }
+  if (opts.user) {
+    buf.push(usernamePasswordAuthenticator(opts.user, opts.pass));
+  }
+  return buf.length === 0 ? noAuthFn() : multiAuthenticator(buf);
+}
+
+export function parseOptions(opts?: ConnectionOptions): ConnectionOptions {
+  const dhp = `${DEFAULT_HOST}:${defaultPort()}`;
+  opts = opts || { servers: [dhp] };
+  opts.servers = opts.servers || [];
+  if (typeof opts.servers === "string") {
+    opts.servers = [opts.servers];
+  }
+
+  if (opts.servers.length > 0 && opts.port) {
+    throw InvalidArgumentError.format(
+      ["servers", "port"],
+      "are mutually exclusive",
+    );
+  }
+
+  if (opts.servers.length === 0 && opts.port) {
+    opts.servers = [`${DEFAULT_HOST}:${opts.port}`];
+  }
+  if (opts.servers && opts.servers.length === 0) {
+    opts.servers = [dhp];
+  }
+  const options = extend(defaultOptions(), opts);
+
+  options.authenticator = buildAuthenticator(options);
+
+  ["reconnectDelayHandler", "authenticator"].forEach((n) => {
+    if (options[n] && typeof options[n] !== "function") {
+      throw TypeError(`'${n}' must be a function`);
+    }
+  });
+
+  if (!options.reconnectDelayHandler) {
+    options.reconnectDelayHandler = (attempt = 0) => {
+      const base = options.reconnectTimeWait ?? DEFAULT_RECONNECT_TIME_WAIT;
+      const max = options.reconnectionDelayMax ?? DEFAULT_RECONNECTION_DELAY_MAX;
+      const factor = options.reconnectionRandomizationFactor ??
+        DEFAULT_RECONNECTION_RANDOMIZATION_FACTOR;
+
+      // exponential backoff with cap + multiplicative jitter
+      if (max > 0) {
+        let d = Math.min(base * Math.pow(2, Math.max(0, attempt)), max);
+        if (factor > 0) {
+          const lo = d * (1 - factor);
+          const hi = d * (1 + factor);
+          d = lo + Math.random() * (hi - lo);
+        }
+        return Math.round(d);
+      }
+
+      // legacy: constant base + additive jitter
+      let extra = options.tls
+        ? options.reconnectJitterTLS
+        : options.reconnectJitter;
+      if (extra) {
+        extra++;
+        extra = Math.floor(Math.random() * extra);
+      }
+      return base + (extra ?? 0);
+    };
+  }
+
+  if (options.inboxPrefix) {
+    createInbox(options.inboxPrefix);
+  }
+
+  // if not set - we set it
+  if (options.resolve === undefined) {
+    // set a default based on whether the client can resolve or not
+    options.resolve = typeof getResolveFn() === "function";
+  }
+
+  if (options.resolve) {
+    if (typeof getResolveFn() !== "function") {
+      throw InvalidArgumentError.format(
+        "resolve",
+        "is not supported in the current runtime",
+      );
+    }
+  }
+
+  return options;
+}
+
+export function checkOptions(info: ServerInfo, options: ConnectionOptions) {
+  const { proto, tls_required: tlsRequired, tls_available: tlsAvailable } =
+    info;
+  if ((proto === undefined || proto < 1) && options.noEcho) {
+    throw new errors.ConnectionError(`server does not support 'noEcho'`);
+  }
+  const tls = tlsRequired || tlsAvailable || false;
+  if (options.tls && !tls) {
+    throw new errors.ConnectionError(`server does not support 'tls'`);
+  }
+}
+
+export function checkUnsupportedOption(prop: string, v?: unknown) {
+  if (v) {
+    throw InvalidArgumentError.format(prop, "is not supported");
+  }
+}