@camera.ui/rpc 1.0.3 → 1.0.4

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

@@ -0,0 +1,113 @@
+/*
+ * 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 {
+  AuthorizationError,
+  backoff,
+  Bench,
+  buildAuthenticator,
+  canonicalMIMEHeaderKey,
+  ClosedConnectionError,
+  ConnectionError,
+  createInbox,
+  credsAuthenticator,
+  deadline,
+  deferred,
+  delay,
+  DrainingConnectionError,
+  Empty,
+  errors,
+  hasWsProtocol,
+  headers,
+  InvalidArgumentError,
+  InvalidOperationError,
+  InvalidSubjectError,
+  jwtAuthenticator,
+  Match,
+  Metric,
+  millis,
+  MsgHdrsImpl,
+  nanos,
+  nkeyAuthenticator,
+  nkeys,
+  NoRespondersError,
+  Nuid,
+  nuid,
+  PermissionViolationError,
+  ProtocolError,
+  RequestError,
+  syncIterator,
+  TimeoutError,
+  tokenAuthenticator,
+  UserAuthenticationExpiredError,
+  usernamePasswordAuthenticator,
+  wsconnect,
+} from "./internal_mod.ts";
+
+export type {
+  Auth,
+  Authenticator,
+  Backoff,
+  BenchOpts,
+  ClientPingStatus,
+  CloseStatus,
+  ClusterUpdateStatus,
+  Codec,
+  ConnectionOptions,
+  Deferred,
+  Delay,
+  DisconnectStatus,
+  ForceReconnectStatus,
+  JwtAuth,
+  LDMStatus,
+  Msg,
+  MsgCallback,
+  MsgHdrs,
+  Nanos,
+  NatsConnection,
+  NKeyAuth,
+  NoAuth,
+  Payload,
+  Perf,
+  Publisher,
+  PublishOptions,
+  QueuedIterator,
+  ReconnectingStatus,
+  ReconnectStatus,
+  ReconnectToServerHandler,
+  RequestManyOptions,
+  RequestOptions,
+  RequestStrategy,
+  ReviverFn,
+  Server,
+  ServerErrorStatus,
+  ServerInfo,
+  ServersChanged,
+  SlowConsumerStatus,
+  StaleConnectionStatus,
+  Stats,
+  Status,
+  SubOpts,
+  Subscription,
+  SubscriptionOptions,
+  SyncIterator,
+  Timeout,
+  TlsOptions,
+  TokenAuth,
+  UserPass,
+  WithRequired,
+  WsConnectionOptions,
+  WsSocketFactory,
+} from "./internal_mod.ts";

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

@@ -0,0 +1,120 @@
+/*
+ * 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 { MsgHdrsImpl } from "./headers.ts";
+import type { MsgArg } from "./parser.ts";
+import { Empty, TD } from "./encoders.ts";
+import type {
+  Msg,
+  MsgHdrs,
+  Payload,
+  Publisher,
+  RequestInfo,
+  ReviverFn,
+} from "./core.ts";
+
+export class MsgImpl implements Msg {
+  _headers?: MsgHdrs;
+  _msg: MsgArg;
+  _rdata: Uint8Array;
+  _reply!: string;
+  _subject!: string;
+  publisher: Publisher;
+
+  constructor(msg: MsgArg, data: Uint8Array, publisher: Publisher) {
+    this._msg = msg;
+    this._rdata = data;
+    this.publisher = publisher;
+  }
+
+  get subject(): string {
+    if (this._subject) {
+      return this._subject;
+    }
+    this._subject = TD.decode(this._msg.subject);
+    return this._subject;
+  }
+
+  get reply(): string {
+    if (this._reply) {
+      return this._reply;
+    }
+    this._reply = TD.decode(this._msg.reply);
+    return this._reply;
+  }
+
+  get sid(): number {
+    return this._msg.sid;
+  }
+
+  get headers(): MsgHdrs | undefined {
+    if (this._msg.hdr > -1 && !this._headers) {
+      const buf = this._rdata.subarray(0, this._msg.hdr);
+      this._headers = MsgHdrsImpl.decode(buf);
+    }
+    return this._headers;
+  }
+
+  get data(): Uint8Array {
+    if (!this._rdata) {
+      return new Uint8Array(0);
+    }
+    return this._msg.hdr > -1
+      ? this._rdata.subarray(this._msg.hdr)
+      : this._rdata;
+  }
+
+  // eslint-ignore-next-line @typescript-eslint/no-explicit-any
+  respond(
+    data: Payload = Empty,
+    opts?: { headers?: MsgHdrs; reply?: string },
+  ): boolean {
+    if (this.reply) {
+      this.publisher.publish(this.reply, data, opts);
+      return true;
+    }
+    return false;
+  }
+
+  size(): number {
+    const subj = this._msg.subject.length;
+    const reply = this._msg.reply?.length || 0;
+    const payloadAndHeaders = this._msg.size === -1 ? 0 : this._msg.size;
+    return subj + reply + payloadAndHeaders;
+  }
+
+  json<T = unknown>(reviver?: ReviverFn): T {
+    return JSON.parse(this.string(), reviver);
+  }
+
+  string(): string {
+    return TD.decode(this.data);
+  }
+
+  requestInfo(): RequestInfo | null {
+    const v = this.headers?.get("Nats-Request-Info");
+    if (v) {
+      return JSON.parse(
+        v,
+        function (this: unknown, key: string, value: unknown): unknown {
+          if ((key === "start" || key === "stop") && value !== "") {
+            return new Date(Date.parse(value as string));
+          }
+          return value;
+        },
+      ) as RequestInfo;
+    }
+    return null;
+  }
+}

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

@@ -0,0 +1,111 @@
+/*
+ * 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.
+ */
+import type { Msg, MsgCallback, Request } from "./core.ts";
+import { createInbox } from "./core.ts";
+import { NoRespondersError, RequestError } from "./errors.ts";
+
+import type { PermissionViolationError } from "./errors.ts";
+
+export class MuxSubscription {
+  baseInbox!: string;
+  reqs: Map<string, Request>;
+
+  constructor() {
+    this.reqs = new Map<string, Request>();
+  }
+
+  size(): number {
+    return this.reqs.size;
+  }
+
+  init(prefix?: string): string {
+    this.baseInbox = `${createInbox(prefix)}.`;
+    return this.baseInbox;
+  }
+
+  add(r: Request) {
+    if (!isNaN(r.received)) {
+      r.received = 0;
+    }
+    this.reqs.set(r.token, r);
+  }
+
+  get(token: string): Request | undefined {
+    return this.reqs.get(token);
+  }
+
+  cancel(r: Request): void {
+    this.reqs.delete(r.token);
+  }
+
+  getToken(m: Msg): string | null {
+    const s = m.subject || "";
+    if (s.indexOf(this.baseInbox) === 0) {
+      return s.substring(this.baseInbox.length);
+    }
+    return null;
+  }
+
+  all(): Request[] {
+    return Array.from(this.reqs.values());
+  }
+
+  handleError(
+    isMuxPermissionError: boolean,
+    err: PermissionViolationError,
+  ): boolean {
+    if (isMuxPermissionError) {
+      // one or more requests queued but mux cannot process them
+      this.all().forEach((r) => {
+        r.resolver(err, {} as Msg);
+      });
+      return true;
+    }
+    if (err.operation === "publish") {
+      const req = this.all().find((s) => {
+        return s.requestSubject === err.subject;
+      });
+      if (req) {
+        req.resolver(err, {} as Msg);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  dispatcher(): MsgCallback<Msg> {
+    return (err: Error | null, m: Msg) => {
+      const token = this.getToken(m);
+      if (token) {
+        const r = this.get(token);
+        if (r) {
+          if (err === null) {
+            err = (m?.data?.length === 0 && m.headers?.code === 503)
+              ? new NoRespondersError(r.requestSubject)
+              : null;
+          }
+          r.resolver(err, m);
+        }
+      }
+    };
+  }
+
+  close() {
+    const err = new RequestError("connection closed");
+    this.reqs.forEach((req) => {
+      req.resolver(err, {} as Msg);
+    });
+  }
+}