@camera.ui/rpc 1.0.3 → 1.0.4

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

@@ -0,0 +1,300 @@
+/*
+ * Copyright 2024 Synadia Communications, Inc
+ * 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.
+ */
+
+/**
+ * Represents an error that is thrown when an invalid subject is encountered.
+ * This class extends the built-in Error object.
+ *
+ * @class
+ * @extends Error
+ */
+export class InvalidSubjectError extends Error {
+  constructor(subject: string, options?: ErrorOptions) {
+    super(`illegal subject: '${subject}'`, options);
+    this.name = "InvalidSubjectError";
+  }
+}
+
+export class InvalidArgumentError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "InvalidArgumentError";
+  }
+
+  static format(
+    property: string | string[],
+    message: string,
+    options?: ErrorOptions,
+  ): InvalidArgumentError {
+    if (Array.isArray(message) && message.length > 1) {
+      message = message[0];
+    }
+    if (Array.isArray(property)) {
+      property = property.map((n) => `'${n}'`);
+      property = property.join(",");
+    } else {
+      property = `'${property}'`;
+    }
+    return new InvalidArgumentError(`${property} ${message}`, options);
+  }
+}
+
+/**
+ * InvalidOperationError is a custom error class that extends the standard Error object.
+ * It represents an error that occurs when an invalid operation is attempted on one of
+ * objects returned by the API. For example, trying to iterate on an object that was
+ * configured with a callback.
+ *
+ * @class InvalidOperationError
+ * @extends {Error}
+ *
+ * @param {string} message - The error message that explains the reason for the error.
+ * @param {ErrorOptions} [options] - Optional parameter to provide additional error options.
+ */
+export class InvalidOperationError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "InvalidOperationError";
+  }
+}
+
+/**
+ * Represents an error indicating that user authentication has expired.
+ * This error is typically thrown when a user attempts to access a connection
+ * but their authentication credentials have expired.
+ */
+export class UserAuthenticationExpiredError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "UserAuthenticationExpiredError";
+  }
+
+  static parse(s: string): UserAuthenticationExpiredError | null {
+    const ss = s.toLowerCase();
+    if (ss.indexOf("user authentication expired") !== -1) {
+      return new UserAuthenticationExpiredError(s);
+    }
+    return null;
+  }
+}
+
+/**
+ * Represents an error related to authorization issues.
+ * Note that these could represent an authorization violation,
+ * or that the account authentication configuration has expired,
+ * or an authentication timeout.
+ */
+export class AuthorizationError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "AuthorizationError";
+  }
+
+  static parse(s: string): AuthorizationError | null {
+    const messages = [
+      "authorization violation",
+      "account authentication expired",
+      "authentication timeout",
+    ];
+
+    const ss = s.toLowerCase();
+
+    for (let i = 0; i < messages.length; i++) {
+      if (ss.indexOf(messages[i]) !== -1) {
+        return new AuthorizationError(s);
+      }
+    }
+
+    return null;
+  }
+}
+
+/**
+ * Class representing an error thrown when an operation is attempted on a closed connection.
+ *
+ * This error is intended to signal that a connection-related operation could not be completed
+ * because the connection is no longer open or has been terminated.
+ *
+ * @class
+ * @extends Error
+ */
+export class ClosedConnectionError extends Error {
+  constructor() {
+    super("closed connection");
+    this.name = "ClosedConnectionError";
+  }
+}
+
+/**
+ * The `ConnectionDrainingError` class represents a specific type of error
+ * that occurs when a connection is being drained.
+ *
+ * This error is typically used in scenarios where connections need to be
+ * gracefully closed or when they are transitioning to an inactive state.
+ *
+ * The error message is set to "connection draining" and the error name is
+ * overridden to "DrainingConnectionError".
+ */
+export class DrainingConnectionError extends Error {
+  constructor() {
+    super("connection draining");
+    this.name = "DrainingConnectionError";
+  }
+}
+
+/**
+ * Represents an error that occurs when a network connection fails.
+ * Extends the built-in Error class to provide additional context for connection-related issues.
+ *
+ * @param {string} message - A human-readable description of the error.
+ * @param {ErrorOptions} [options] - Optional settings for customizing the error behavior.
+ */
+export class ConnectionError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "ConnectionError";
+  }
+}
+
+/**
+ * Represents an error encountered during protocol operations.
+ * This class extends the built-in `Error` class, providing a specific
+ * error type called `ProtocolError`.
+ *
+ * @param {string} message - A descriptive message describing the error.
+ * @param {ErrorOptions} [options] - Optional parameters to include additional details.
+ */
+export class ProtocolError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "ProtocolError";
+  }
+}
+
+/**
+ * Class representing an error that occurs during an request operation
+ * (such as TimeoutError, or NoRespondersError, or some other error).
+ *
+ * @extends Error
+ */
+export class RequestError extends Error {
+  constructor(message = "", options?: ErrorOptions) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+
+  isNoResponders(): boolean {
+    return this.cause instanceof NoRespondersError;
+  }
+}
+
+/**
+ * TimeoutError is a custom error class that extends the built-in Error class.
+ * It is used to represent an error that occurs when an operation exceeds a
+ * predefined time limit.
+ *
+ * @class
+ * @extends {Error}
+ */
+export class TimeoutError extends Error {
+  constructor(options?: ErrorOptions) {
+    super("timeout", options);
+    this.name = "TimeoutError";
+  }
+}
+
+/**
+ * NoRespondersError is an error thrown when no responders (no service is
+ * subscribing to the subject) are found for a given subject. This error
+ * is typically found as the cause for a RequestError
+ *
+ * @extends Error
+ *
+ * @param {string} subject - The subject for which no responders were found.
+ * @param {ErrorOptions} [options] - Optional error options.
+ */
+export class NoRespondersError extends Error {
+  subject: string;
+  constructor(subject: string, options?: ErrorOptions) {
+    super(`no responders: '${subject}'`, options);
+    this.subject = subject;
+    this.name = "NoResponders";
+  }
+}
+
+/**
+ * Class representing a Permission Violation Error.
+ * It provides information about the operation (either "publish" or "subscription")
+ * and the subject used for the operation and the optional queue (if a subscription).
+ *
+ * This error is terminal for a subscription.
+ */
+export class PermissionViolationError extends Error {
+  operation: "publish" | "subscription";
+  subject: string;
+  queue?: string;
+
+  constructor(
+    message: string,
+    operation: "publish" | "subscription",
+    subject: string,
+    queue?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "PermissionViolationError";
+    this.operation = operation;
+    this.subject = subject;
+    this.queue = queue;
+  }
+
+  static parse(s: string): PermissionViolationError | null {
+    const t = s ? s.toLowerCase() : "";
+    if (t.indexOf("permissions violation") === -1) {
+      return null;
+    }
+    let operation: "publish" | "subscription" = "publish";
+    let subject = "";
+    let queue: string | undefined = undefined;
+    const m = s.match(/(Publish|Subscription) to "(\S+)"/);
+    if (m) {
+      operation = m[1].toLowerCase() as "publish" | "subscription";
+      subject = m[2];
+      if (operation === "subscription") {
+        const qm = s.match(/using queue "(\S+)"/);
+        if (qm) {
+          queue = qm[1];
+        }
+      }
+    }
+    return new PermissionViolationError(s, operation, subject, queue);
+  }
+}
+
+export const errors = {
+  AuthorizationError,
+  ClosedConnectionError,
+  ConnectionError,
+  DrainingConnectionError,
+  InvalidArgumentError,
+  InvalidOperationError,
+  InvalidSubjectError,
+  NoRespondersError,
+  PermissionViolationError,
+  ProtocolError,
+  RequestError,
+  TimeoutError,
+  UserAuthenticationExpiredError,
+};

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

@@ -0,0 +1,315 @@
+/*
+ * Copyright 2020-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.
+ */
+
+// Heavily inspired by Golang's https://golang.org/src/net/http/header.go
+
+import { TD, TE } from "./encoders.ts";
+import type { MsgHdrs } from "./core.ts";
+import { Match } from "./core.ts";
+import { InvalidArgumentError } from "./errors.ts";
+
+// https://www.ietf.org/rfc/rfc822.txt
+// 3.1.2.  STRUCTURE OF HEADER FIELDS
+//
+// Once a field has been unfolded, it may be viewed as being com-
+// posed of a field-name followed by a colon (":"), followed by a
+// field-body, and  terminated  by  a  carriage-return/line-feed.
+// The  field-name must be composed of printable ASCII characters
+// (i.e., characters that  have  values  between  33.  and  126.,
+// decimal, except colon).  The field-body may be composed of any
+// ASCII characters, except CR or LF.  (While CR and/or LF may be
+// present  in the actual text, they are removed by the action of
+// unfolding the field.)
+export function canonicalMIMEHeaderKey(k: string): string {
+  const a = 97;
+  const A = 65;
+  const Z = 90;
+  const z = 122;
+  const dash = 45;
+  const colon = 58;
+  const start = 33;
+  const end = 126;
+  const toLower = a - A;
+
+  let upper = true;
+  const buf: number[] = new Array(k.length);
+  for (let i = 0; i < k.length; i++) {
+    let c = k.charCodeAt(i);
+    if (c === colon || c < start || c > end) {
+      throw InvalidArgumentError.format(
+        "header",
+        `'${k[i]}' is not a valid character in a header name`,
+      );
+    }
+    if (upper && a <= c && c <= z) {
+      c -= toLower;
+    } else if (!upper && A <= c && c <= Z) {
+      c += toLower;
+    }
+    buf[i] = c;
+    upper = c == dash;
+  }
+  return String.fromCharCode(...buf);
+}
+
+export function headers(code = 0, description = ""): MsgHdrs {
+  if (code === 0 && description !== "") {
+    throw InvalidArgumentError.format("code", "is required");
+  } else if (code > 0 && description === "") {
+    throw InvalidArgumentError.format("description", "is required");
+  }
+  return new MsgHdrsImpl(code, description);
+}
+
+const HEADER = "NATS/1.0";
+
+export class MsgHdrsImpl implements MsgHdrs {
+  _code: number;
+  headers: Map<string, string[]>;
+  _description: string;
+
+  constructor(code = 0, description = "") {
+    this._code = code;
+    this._description = description;
+    this.headers = new Map();
+  }
+
+  [Symbol.iterator](): IterableIterator<[string, string[]]> {
+    return this.headers.entries();
+  }
+
+  size(): number {
+    return this.headers.size;
+  }
+
+  equals(mh: MsgHdrsImpl): boolean {
+    if (
+      mh && this.headers.size === mh.headers.size &&
+      this._code === mh._code
+    ) {
+      for (const [k, v] of this.headers) {
+        const a = mh.values(k);
+        if (v.length !== a.length) {
+          return false;
+        }
+        const vv = [...v].sort();
+        const aa = [...a].sort();
+        for (let i = 0; i < vv.length; i++) {
+          if (vv[i] !== aa[i]) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  static decode(a: Uint8Array): MsgHdrsImpl {
+    const mh = new MsgHdrsImpl();
+    const s = TD.decode(a);
+    const lines = s.split("\r\n");
+    const h = lines[0];
+    if (h !== HEADER) {
+      // malformed headers could add extra space without adding a code or description
+      let str = h.replace(HEADER, "").trim();
+      if (str.length > 0) {
+        mh._code = parseInt(str, 10);
+        if (isNaN(mh._code)) {
+          mh._code = 0;
+        }
+        const scode = mh._code.toString();
+        str = str.replace(scode, "");
+        mh._description = str.trim();
+      }
+    }
+    if (lines.length >= 1) {
+      lines.slice(1).map((s) => {
+        if (s) {
+          const idx = s.indexOf(":");
+          if (idx > -1) {
+            const k = s.slice(0, idx);
+            const v = s.slice(idx + 1).trim();
+            mh.append(k, v);
+          }
+        }
+      });
+    }
+    return mh;
+  }
+
+  toString(): string {
+    if (this.headers.size === 0 && this._code === 0) {
+      return "";
+    }
+    let s = HEADER;
+    if (this._code > 0 && this._description !== "") {
+      s += ` ${this._code} ${this._description}`;
+    }
+    for (const [k, v] of this.headers) {
+      for (let i = 0; i < v.length; i++) {
+        s = `${s}\r\n${k}: ${v[i]}`;
+      }
+    }
+    return `${s}\r\n\r\n`;
+  }
+
+  encode(): Uint8Array {
+    return TE.encode(this.toString());
+  }
+
+  static validHeaderValue(k: string): string {
+    const inv = /[\r\n]/;
+    if (inv.test(k)) {
+      throw InvalidArgumentError.format(
+        "header",
+        "values cannot contain \\r or \\n",
+      );
+    }
+    return k.trim();
+  }
+
+  keys(): string[] {
+    const keys = [];
+    for (const sk of this.headers.keys()) {
+      keys.push(sk);
+    }
+    return keys;
+  }
+
+  findKeys(k: string, match: Match = Match.Exact): string[] {
+    const keys = this.keys();
+    switch (match) {
+      case Match.Exact:
+        return keys.filter((v) => {
+          return v === k;
+        });
+      case Match.CanonicalMIME:
+        k = canonicalMIMEHeaderKey(k);
+        return keys.filter((v) => {
+          return v === k;
+        });
+      default: {
+        const lci = k.toLowerCase();
+        return keys.filter((v) => {
+          return lci === v.toLowerCase();
+        });
+      }
+    }
+  }
+
+  get(k: string, match = Match.Exact): string {
+    const keys = this.findKeys(k, match);
+    if (keys.length) {
+      const v = this.headers.get(keys[0]);
+      if (v) {
+        return Array.isArray(v) ? v[0] : v;
+      }
+    }
+    return "";
+  }
+
+  last(k: string, match = Match.Exact): string {
+    const keys = this.findKeys(k, match);
+    if (keys.length) {
+      const v = this.headers.get(keys[0]);
+      if (v) {
+        return Array.isArray(v) ? v[v.length - 1] : v;
+      }
+    }
+    return "";
+  }
+
+  has(k: string, match: Match = Match.Exact): boolean {
+    return this.findKeys(k, match).length > 0;
+  }
+
+  set(k: string, v: string, match: Match = Match.Exact): void {
+    this.delete(k, match);
+    this.append(k, v, match);
+  }
+
+  append(k: string, v: string, match: Match = Match.Exact): void {
+    // validate the key
+    const ck = canonicalMIMEHeaderKey(k);
+    if (match === Match.CanonicalMIME) {
+      k = ck;
+    }
+    // if we get non-sensical ignores/etc, we should try
+    // to do the right thing and use the first key that matches
+    const keys = this.findKeys(k, match);
+    k = keys.length > 0 ? keys[0] : k;
+
+    const value = MsgHdrsImpl.validHeaderValue(v);
+    let a = this.headers.get(k);
+    if (!a) {
+      a = [];
+      this.headers.set(k, a);
+    }
+    a.push(value);
+  }
+
+  values(k: string, match: Match = Match.Exact): string[] {
+    const buf: string[] = [];
+    const keys = this.findKeys(k, match);
+    keys.forEach((v) => {
+      const values = this.headers.get(v);
+      if (values) {
+        buf.push(...values);
+      }
+    });
+    return buf;
+  }
+
+  delete(k: string, match: Match = Match.Exact): void {
+    const keys = this.findKeys(k, match);
+    keys.forEach((v) => {
+      this.headers.delete(v);
+    });
+  }
+
+  get hasError(): boolean {
+    return this._code >= 300;
+  }
+
+  get status(): string {
+    return `${this._code} ${this._description}`.trim();
+  }
+
+  toRecord(): Record<string, string[]> {
+    const data = {} as Record<string, string[]>;
+    this.keys().forEach((v) => {
+      data[v] = this.values(v);
+    });
+    return data;
+  }
+
+  get code(): number {
+    return this._code;
+  }
+
+  get description(): string {
+    return this._description;
+  }
+
+  static fromRecord(r: Record<string, string[]>): MsgHdrs {
+    const h = new MsgHdrsImpl();
+    for (const k in r) {
+      const v = r[k];
+      h.headers.set(k, Array.isArray(v) ? v : [`${v}`]);
+    }
+    return h;
+  }
+}