@camera.ui/rpc 1.0.3 → 1.0.4

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

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2020-2024 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 type { Deferred } from "./util.ts";
+import { deferred } from "./util.ts";
+import type { Status } from "./core.ts";
+
+export interface PH {
+  flush(p?: Deferred<void>): Promise<void>;
+  disconnect(): void;
+  dispatchStatus(status: Status): void;
+}
+
+export class Heartbeat {
+  ph: PH;
+  interval: number;
+  maxOut: number;
+  timeout: number;
+  timer?: number;
+  pendings: Promise<void>[];
+
+  constructor(ph: PH, interval: number, maxOut: number, timeout = 0) {
+    this.ph = ph;
+    this.interval = interval;
+    this.maxOut = maxOut;
+    this.timeout = timeout;
+    this.pendings = [];
+  }
+
+  // api to start the heartbeats, since this can be
+  // spuriously called from dial, ensure we don't
+  // leak timers
+  start() {
+    this.cancel();
+    this._schedule();
+  }
+
+  // api for canceling the heartbeats, if stale is
+  // true it will initiate a client disconnect
+  cancel(stale?: boolean) {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = undefined;
+    }
+    this._reset();
+    if (stale) {
+      this.ph.disconnect();
+    }
+  }
+
+  _schedule() {
+    // @ts-ignore: node is not a number - we treat this opaquely
+    this.timer = setTimeout(() => {
+      this.ph.dispatchStatus(
+        { type: "ping", pendingPings: this.pendings.length + 1 },
+      );
+      if (this.pendings.length === this.maxOut) {
+        this.cancel(true);
+        return;
+      }
+      const ping = deferred<void>();
+
+      // if no PONG within `timeout` ms, kill
+      // the connection without waiting for the next interval tick.
+      let pingTimer: ReturnType<typeof setTimeout> | undefined;
+      if (this.timeout > 0) {
+        pingTimer = setTimeout(() => {
+          pingTimer = undefined;
+          this.cancel(true);
+        }, this.timeout);
+      }
+      const clearPingTimer = () => {
+        if (pingTimer !== undefined) {
+          clearTimeout(pingTimer);
+          pingTimer = undefined;
+        }
+      };
+
+      this.ph.flush(ping)
+        .then(() => {
+          clearPingTimer();
+          this._reset();
+        })
+        .catch(() => {
+          // we disconnected - pongs were rejected
+          clearPingTimer();
+          this.cancel();
+        });
+      this.pendings.push(ping);
+      this._schedule();
+    }, this.interval);
+  }
+
+  _reset() {
+    // clear pendings after resolving them
+    this.pendings = this.pendings.filter((p) => {
+      const d = p as Deferred<void>;
+      d.resolve();
+      return false;
+    });
+  }
+}

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

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2022 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.
+ */
+
+/**
+ * Called with the number of missed heartbeats.
+ * If the function returns true, the monitor will cancel monitoring.
+ */
+export type IdleHeartbeatFn = (n: number) => boolean;
+
+/**
+ * IdleHeartbeatOptions
+ */
+export type IdleHeartbeatOptions = {
+  /**
+   * @field maxOut - optional maximum number of missed heartbeats before notifying (default is 2)
+   */
+  maxOut: number;
+  /**
+   * @field cancelAfter - optional timer to auto cancel monitoring in millis
+   */
+  cancelAfter: number;
+};
+
+export class IdleHeartbeatMonitor {
+  interval: number;
+  maxOut: number;
+  cancelAfter: number;
+  timer?: number;
+  autoCancelTimer?: number;
+  last!: number;
+  missed: number;
+  count: number;
+  callback: IdleHeartbeatFn;
+
+  /**
+   * Constructor
+   * @param interval in millis to check
+   * @param cb a callback to report when heartbeats are missed
+   * @param opts monitor options @see IdleHeartbeatOptions
+   */
+  constructor(
+    interval: number,
+    cb: IdleHeartbeatFn,
+    opts: Partial<IdleHeartbeatOptions> = { maxOut: 2 },
+  ) {
+    this.interval = interval;
+    this.maxOut = opts?.maxOut || 2;
+    this.cancelAfter = opts?.cancelAfter || 0;
+    this.last = Date.now();
+    this.missed = 0;
+    this.count = 0;
+    this.callback = cb;
+
+    this._schedule();
+  }
+
+  /**
+   * cancel monitoring
+   */
+  cancel() {
+    if (this.autoCancelTimer) {
+      clearTimeout(this.autoCancelTimer);
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    this.timer = 0;
+    this.autoCancelTimer = 0;
+    this.missed = 0;
+  }
+
+  /**
+   * work signals that there was work performed
+   */
+  work() {
+    this.last = Date.now();
+    this.missed = 0;
+  }
+
+  /**
+   * internal api to change the interval, cancelAfter and maxOut
+   * @param interval
+   * @param cancelAfter
+   * @param maxOut
+   */
+  _change(interval: number, cancelAfter = 0, maxOut = 2) {
+    this.interval = interval;
+    this.maxOut = maxOut;
+    this.cancelAfter = cancelAfter;
+    this.restart();
+  }
+
+  /**
+   * cancels and restarts the monitoring
+   */
+  restart() {
+    this.cancel();
+    this._schedule();
+  }
+
+  /**
+   * internal api called to start monitoring
+   */
+  _schedule() {
+    if (this.cancelAfter > 0) {
+      // @ts-ignore: in node is not a number - we treat this opaquely
+      this.autoCancelTimer = setTimeout(() => {
+        this.cancel();
+      }, this.cancelAfter);
+    }
+    // @ts-ignore: in node is not a number - we treat this opaquely
+    this.timer = setInterval(() => {
+      this.count++;
+      if ((Date.now() - this.last) > this.interval) {
+        this.missed++;
+      }
+      if (this.missed >= this.maxOut) {
+        try {
+          if (this.callback(this.missed) === true) {
+            this.cancel();
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      }
+    }, this.interval);
+  }
+}

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

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2024 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.
+ */
+
+export { NatsConnectionImpl } from "./nats.ts";
+export { Nuid, nuid } from "./nuid.ts";
+
+export { MsgImpl } from "./msg.ts";
+export { getResolveFn, setTransportFactory } from "./transport.ts";
+export type { Transport, TransportFactory } from "./transport.ts";
+export { Connect, INFO, ProtocolHandler } from "./protocol.ts";
+export type {
+  Backoff,
+  Deferred,
+  Delay,
+  ErrorResult,
+  Perf,
+  Prettify,
+  Result,
+  Timeout,
+  ValueResult,
+  WithRequired,
+} from "./util.ts";
+export {
+  backoff,
+  collect,
+  deadline,
+  deferred,
+  delay,
+  extend,
+  millis,
+  nanos,
+  render,
+  SimpleMutex,
+  timeout,
+} from "./util.ts";
+export { canonicalMIMEHeaderKey, headers, MsgHdrsImpl } from "./headers.ts";
+export { Heartbeat } from "./heartbeats.ts";
+export type { PH } from "./heartbeats.ts";
+export { MuxSubscription } from "./muxsubscription.ts";
+export { DataBuffer } from "./databuffer.ts";
+export {
+  buildAuthenticator,
+  checkOptions,
+  checkUnsupportedOption,
+  DEFAULT_MAX_RECONNECT_ATTEMPTS,
+  defaultOptions,
+  hasWsProtocol,
+  parseOptions,
+} from "./options.ts";
+export { RequestOne } from "./request.ts";
+export {
+  credsAuthenticator,
+  jwtAuthenticator,
+  nkeyAuthenticator,
+  tokenAuthenticator,
+  usernamePasswordAuthenticator,
+} from "./authenticator.ts";
+export type { Codec } from "./codec.ts";
+export * from "./nkeys.ts";
+export { QueuedIteratorImpl } from "./queued_iterator.ts";
+export type { MsgArg, ParserEvent } from "./parser.ts";
+export { describe, Kind, Parser, State } from "./parser.ts";
+export { DenoBuffer, MAX_SIZE, readAll, writeAll } from "./denobuffer.ts";
+export { Bench, Metric } from "./bench.ts";
+export type { BenchOpts } from "./bench.ts";
+export { TD, TE } from "./encoders.ts";
+export { ipV4, isIP, parseIP } from "./ipparser.ts";
+
+export type { SemVer } from "./semver.ts";
+export { compare, Feature, Features, parseSemVer } from "./semver.ts";
+export { Empty } from "./types.ts";
+export { extractProtocolMessage, protoLen } from "./transport.ts";
+
+export type {
+  Auth,
+  Authenticator,
+  CallbackFn,
+  CallbackOptionalErrorFn,
+  ClientPingStatus,
+  CloseStatus,
+  ClusterUpdateStatus,
+  ConnectionClosedListener,
+  ConnectionOptions,
+  DisconnectStatus,
+  Dispatcher,
+  ForceReconnectStatus,
+  JwtAuth,
+  LDMStatus,
+  Msg,
+  MsgCallback,
+  MsgHdrs,
+  Nanos,
+  NatsConnection,
+  NKeyAuth,
+  NoAuth,
+  Payload,
+  Publisher,
+  PublishOptions,
+  QueuedIterator,
+  ReconnectingStatus,
+  ReconnectStatus,
+  ReconnectToServerHandler,
+  Request,
+  RequestManyOptions,
+  RequestOptions,
+  RequestStrategy,
+  ReviverFn,
+  Server,
+  ServerErrorStatus,
+  ServerInfo,
+  ServersChanged,
+  SlowConsumerStatus,
+  StaleConnectionStatus,
+  Stats,
+  Status,
+  SubOpts,
+  Subscription,
+  SubscriptionOptions,
+  SyncIterator,
+  TlsOptions,
+  TokenAuth,
+  UserPass,
+} from "./core.ts";
+
+export { createInbox, Match, syncIterator } from "./core.ts";
+export { SubscriptionImpl, Subscriptions } from "./protocol.ts";
+
+export type {
+  IdleHeartbeatFn,
+  IdleHeartbeatOptions,
+} from "./idleheartbeat_monitor.ts";
+export { IdleHeartbeatMonitor } from "./idleheartbeat_monitor.ts";
+
+export { isIPV4OrHostname, Servers } from "./servers.ts";
+
+export { wsconnect, wsUrlParseFn } from "./ws_transport.ts";
+
+export type { WsConnectionOptions, WsSocketFactory } from "./ws_transport.ts";
+
+export {
+  AuthorizationError,
+  ClosedConnectionError,
+  ConnectionError,
+  DrainingConnectionError,
+  errors,
+  InvalidArgumentError,
+  InvalidOperationError,
+  InvalidSubjectError,
+  NoRespondersError,
+  PermissionViolationError,
+  ProtocolError,
+  RequestError,
+  TimeoutError,
+  UserAuthenticationExpiredError,
+} from "./errors.ts";

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

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2020-2021 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.
+ */
+
+// JavaScript port of go net/ip/ParseIP
+// https://github.com/golang/go/blob/master/src/net/ip.go
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+const IPv4LEN = 4;
+const IPv6LEN = 16;
+const ASCII0 = 48;
+const ASCII9 = 57;
+const ASCIIA = 65;
+const ASCIIF = 70;
+const ASCIIa = 97;
+const ASCIIf = 102;
+const big = 0xFFFFFF;
+
+export function ipV4(a: number, b: number, c: number, d: number): Uint8Array {
+  const ip = new Uint8Array(IPv6LEN);
+  const prefix = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff];
+  prefix.forEach((v, idx) => {
+    ip[idx] = v;
+  });
+  ip[12] = a;
+  ip[13] = b;
+  ip[14] = c;
+  ip[15] = d;
+
+  return ip;
+}
+
+export function isIP(h: string): boolean {
+  return parseIP(h) !== undefined;
+}
+
+export function parseIP(h: string): Uint8Array | undefined {
+  for (let i = 0; i < h.length; i++) {
+    switch (h[i]) {
+      case ".":
+        return parseIPv4(h);
+      case ":":
+        return parseIPv6(h);
+    }
+  }
+  return;
+}
+
+function parseIPv4(s: string): Uint8Array | undefined {
+  const ip = new Uint8Array(IPv4LEN);
+  for (let i = 0; i < IPv4LEN; i++) {
+    if (s.length === 0) {
+      return undefined;
+    }
+    if (i > 0) {
+      if (s[0] !== ".") {
+        return undefined;
+      }
+      s = s.substring(1);
+    }
+    const { n, c, ok } = dtoi(s);
+    if (!ok || n > 0xFF) {
+      return undefined;
+    }
+    s = s.substring(c);
+    ip[i] = n;
+  }
+  return ipV4(ip[0], ip[1], ip[2], ip[3]);
+}
+
+function parseIPv6(s: string): Uint8Array | undefined {
+  const ip = new Uint8Array(IPv6LEN);
+  let ellipsis = -1;
+
+  if (s.length >= 2 && s[0] === ":" && s[1] === ":") {
+    ellipsis = 0;
+    s = s.substring(2);
+    if (s.length === 0) {
+      return ip;
+    }
+  }
+
+  let i = 0;
+  while (i < IPv6LEN) {
+    const { n, c, ok } = xtoi(s);
+    if (!ok || n > 0xFFFF) {
+      return undefined;
+    }
+
+    if (c < s.length && s[c] === ".") {
+      if (ellipsis < 0 && i != IPv6LEN - IPv4LEN) {
+        return undefined;
+      }
+      if (i + IPv4LEN > IPv6LEN) {
+        return undefined;
+      }
+      const ip4 = parseIPv4(s);
+      if (ip4 === undefined) {
+        return undefined;
+      }
+      ip[i] = ip4[12];
+      ip[i + 1] = ip4[13];
+      ip[i + 2] = ip4[14];
+      ip[i + 3] = ip4[15];
+      s = "";
+      i += IPv4LEN;
+      break;
+    }
+
+    ip[i] = n >> 8;
+    ip[i + 1] = n;
+    i += 2;
+
+    s = s.substring(c);
+    if (s.length === 0) {
+      break;
+    }
+
+    if (s[0] !== ":" || s.length == 1) {
+      return undefined;
+    }
+
+    s = s.substring(1);
+
+    if (s[0] === ":") {
+      if (ellipsis >= 0) {
+        return undefined;
+      }
+      ellipsis = i;
+      s = s.substring(1);
+      if (s.length === 0) {
+        break;
+      }
+    }
+  }
+
+  if (s.length !== 0) {
+    return undefined;
+  }
+
+  if (i < IPv6LEN) {
+    if (ellipsis < 0) {
+      return undefined;
+    }
+
+    const n = IPv6LEN - i;
+    for (let j = i - 1; j >= ellipsis; j--) {
+      ip[j + n] = ip[j];
+    }
+    for (let j = ellipsis + n - 1; j >= ellipsis; j--) {
+      ip[j] = 0;
+    }
+  } else if (ellipsis >= 0) {
+    return undefined;
+  }
+  return ip;
+}
+
+function dtoi(s: string): { n: number; c: number; ok: boolean } {
+  let i = 0;
+  let n = 0;
+  for (
+    i = 0;
+    i < s.length && ASCII0 <= s.charCodeAt(i) && s.charCodeAt(i) <= ASCII9;
+    i++
+  ) {
+    n = n * 10 + (s.charCodeAt(i) - ASCII0);
+    if (n >= big) {
+      return { n: big, c: i, ok: false };
+    }
+  }
+  if (i === 0) {
+    return { n: 0, c: 0, ok: false };
+  }
+  return { n: n, c: i, ok: true };
+}
+
+function xtoi(s: string): { n: number; c: number; ok: boolean } {
+  let n = 0;
+  let i = 0;
+  for (i = 0; i < s.length; i++) {
+    if (ASCII0 <= s.charCodeAt(i) && s.charCodeAt(i) <= ASCII9) {
+      n *= 16;
+      n += s.charCodeAt(i) - ASCII0;
+    } else if (ASCIIa <= s.charCodeAt(i) && s.charCodeAt(i) <= ASCIIf) {
+      n *= 16;
+      n += (s.charCodeAt(i) - ASCIIa) + 10;
+    } else if (ASCIIA <= s.charCodeAt(i) && s.charCodeAt(i) <= ASCIIF) {
+      n *= 16;
+      n += (s.charCodeAt(i) - ASCIIA) + 10;
+    } else {
+      break;
+    }
+    if (n >= big) {
+      return { n: 0, c: i, ok: false };
+    }
+  }
+  if (i === 0) {
+    return { n: 0, c: i, ok: false };
+  }
+  return { n: n, c: i, ok: true };
+}