@camera.ui/rpc 1.0.3 → 1.0.4

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

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2020-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.
+ */
+import type { Deferred } from "./util.ts";
+import { deferred } from "./util.ts";
+import type { QueuedIterator } from "./core.ts";
+import type { CallbackFn, Dispatcher } from "./core.ts";
+import { InvalidOperationError } from "./errors.ts";
+
+export class QueuedIteratorImpl<T> implements QueuedIterator<T>, Dispatcher<T> {
+  inflight: number;
+  processed: number;
+  // this is updated by the protocol
+  received: number;
+  noIterator: boolean;
+  iterClosed: Deferred<void | Error>;
+  done: boolean;
+  signal: Deferred<void>;
+  yields: (T | CallbackFn)[];
+  filtered: number;
+  pendingFiltered: number;
+  ctx?: unknown;
+  _data?: unknown; //data is for use by extenders in any way they like
+  err?: Error;
+  time: number;
+  profile: boolean;
+  yielding: boolean;
+  didBreak: boolean;
+
+  constructor() {
+    this.inflight = 0;
+    this.filtered = 0;
+    this.pendingFiltered = 0;
+    this.processed = 0;
+    this.received = 0;
+    this.noIterator = false;
+    this.done = false;
+    this.signal = deferred<void>();
+    this.yields = [];
+    this.iterClosed = deferred<void | Error>();
+    this.time = 0;
+    this.yielding = false;
+    this.didBreak = false;
+    this.profile = false;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.iterate();
+  }
+
+  push(v: T | CallbackFn): void {
+    if (this.done) {
+      return;
+    }
+    // if they `break` from a `for await`, any signaling that is pushed via
+    // a function is not handled this can prevent closed promises from
+    // resolving downstream.
+    if (this.didBreak) {
+      if (typeof v === "function") {
+        const cb = v as CallbackFn;
+        try {
+          cb();
+        } catch (_) {
+          // ignored
+        }
+      }
+      return;
+    }
+    if (typeof v === "function") {
+      this.pendingFiltered++;
+    }
+    this.yields.push(v);
+    this.signal.resolve();
+  }
+
+  async *iterate(): AsyncIterableIterator<T> {
+    if (this.noIterator) {
+      throw new InvalidOperationError(
+        "iterator cannot be used when a callback is registered",
+      );
+    }
+    if (this.yielding) {
+      throw new InvalidOperationError("iterator is already yielding");
+    }
+    this.yielding = true;
+    try {
+      while (true) {
+        if (this.yields.length === 0) {
+          await this.signal;
+        }
+        if (this.err) {
+          throw this.err;
+        }
+        const yields = this.yields;
+        this.inflight = yields.length;
+        this.yields = [];
+        for (let i = 0; i < yields.length; i++) {
+          if (typeof yields[i] === "function") {
+            this.pendingFiltered--;
+            const fn = yields[i] as CallbackFn;
+            try {
+              fn();
+            } catch (err) {
+              // failed on the invocation - fail the iterator
+              // so they know to fix the callback
+              throw err;
+            }
+            // fn could have also set an error
+            if (this.err) {
+              throw this.err;
+            }
+            continue;
+          }
+
+          this.processed++;
+          this.inflight--;
+          const start = this.profile ? Date.now() : 0;
+          yield yields[i] as T;
+          this.time = this.profile ? Date.now() - start : 0;
+        }
+        // yielding could have paused and microtask
+        // could have added messages. Prevent allocations
+        // if possible
+        if (this.done) {
+          break;
+        } else if (this.yields.length === 0) {
+          yields.length = 0;
+          this.yields = yields;
+          this.signal = deferred();
+        }
+      }
+    } finally {
+      // the iterator used break/return
+      this.didBreak = true;
+      this.stop();
+    }
+  }
+
+  stop(err?: Error): void {
+    if (this.done) {
+      return;
+    }
+    this.err = err;
+    this.done = true;
+    this.signal.resolve();
+    this.iterClosed.resolve(err);
+  }
+
+  getProcessed(): number {
+    return this.noIterator ? this.received : this.processed;
+  }
+
+  getPending(): number {
+    return this.yields.length + this.inflight - this.pendingFiltered;
+  }
+
+  getReceived(): number {
+    return this.received - this.filtered;
+  }
+}

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

@@ -0,0 +1,177 @@
+/*
+ * 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.
+ */
+import type { Deferred, Timeout } from "./util.ts";
+import { deferred, randomToken, timeout } from "./util.ts";
+import type { MuxSubscription } from "./muxsubscription.ts";
+import type {
+  Msg,
+  Request,
+  RequestManyOptions,
+  RequestOptions,
+} from "./core.ts";
+import { errors, RequestError, TimeoutError } from "./errors.ts";
+
+export class BaseRequest {
+  token: string;
+  received: number;
+  ctx?: RequestError;
+  requestSubject: string;
+  mux: MuxSubscription;
+
+  constructor(
+    mux: MuxSubscription,
+    requestSubject: string,
+    asyncTraces = true,
+  ) {
+    this.mux = mux;
+    this.requestSubject = requestSubject;
+    this.received = 0;
+    this.token = randomToken();
+    if (asyncTraces) {
+      this.ctx = new RequestError();
+    }
+  }
+}
+
+export interface RequestManyOptionsInternal extends RequestManyOptions {
+  callback: (err: Error | null, msg: Msg | null) => void;
+}
+
+/**
+ * Request expects multiple message response
+ * the request ends when the timer expires,
+ * an error arrives or an expected count of messages
+ * arrives, end is signaled by a null message
+ */
+export class RequestMany extends BaseRequest implements Request {
+  callback!: (err: Error | null, msg: Msg | null) => void;
+  done: Deferred<void>;
+  timer: number;
+  max: number;
+  opts: Partial<RequestManyOptionsInternal>;
+  constructor(
+    mux: MuxSubscription,
+    requestSubject: string,
+    opts: Partial<RequestManyOptions> = { maxWait: 1000 },
+  ) {
+    super(mux, requestSubject);
+    this.opts = opts;
+    if (typeof this.opts.callback !== "function") {
+      throw new TypeError("callback must be a function");
+    }
+    this.callback = this.opts.callback;
+
+    this.max = typeof opts.maxMessages === "number" && opts.maxMessages > 0
+      ? opts.maxMessages
+      : -1;
+    this.done = deferred();
+    this.done.then(() => {
+      this.callback(null, null);
+    });
+    // @ts-ignore: node is not a number
+    this.timer = setTimeout(() => {
+      this.cancel();
+    }, opts.maxWait);
+  }
+
+  cancel(err?: Error): void {
+    if (err) {
+      this.callback(err, null);
+    }
+    clearTimeout(this.timer);
+    this.mux.cancel(this);
+    this.done.resolve();
+  }
+
+  resolver(err: Error | null, msg: Msg): void {
+    if (err) {
+      if (this.ctx) {
+        err.stack += `\n\n${this.ctx.stack}`;
+      }
+      this.cancel(err as Error);
+    } else {
+      this.callback(null, msg);
+      if (this.opts.strategy === "count") {
+        this.max--;
+        if (this.max === 0) {
+          this.cancel();
+        }
+      }
+
+      if (this.opts.strategy === "stall") {
+        clearTimeout(this.timer);
+        // @ts-ignore: node is not a number
+        this.timer = setTimeout(() => {
+          this.cancel();
+        }, this.opts.stall || 300);
+      }
+
+      if (this.opts.strategy === "sentinel") {
+        if (msg && msg.data.length === 0) {
+          this.cancel();
+        }
+      }
+    }
+  }
+}
+
+export class RequestOne extends BaseRequest implements Request {
+  deferred: Deferred<Msg>;
+  timer: Timeout<Msg>;
+
+  constructor(
+    mux: MuxSubscription,
+    requestSubject: string,
+    opts: RequestOptions = { timeout: 1000 },
+    asyncTraces = true,
+  ) {
+    super(mux, requestSubject, asyncTraces);
+    // extend(this, opts);
+    this.deferred = deferred();
+    this.timer = timeout<Msg>(opts.timeout, asyncTraces);
+  }
+
+  resolver(err: Error | null, msg: Msg): void {
+    if (this.timer) {
+      this.timer.cancel();
+    }
+    if (err) {
+      // we have proper stack on timeout
+      if (!(err instanceof TimeoutError)) {
+        if (this.ctx) {
+          this.ctx.message = err.message;
+          this.ctx.cause = err;
+          err = this.ctx;
+        } else {
+          err = new errors.RequestError(err.message, { cause: err });
+        }
+      }
+      this.deferred.reject(err);
+    } else {
+      this.deferred.resolve(msg);
+    }
+    this.cancel();
+  }
+
+  cancel(err?: Error): void {
+    if (this.timer) {
+      this.timer.cancel();
+    }
+    this.mux.cancel(this);
+    this.deferred.reject(
+      err ? err : new RequestError("cancelled"),
+    );
+  }
+}

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

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2022-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.
+ */
+
+export type SemVer = { major: number; minor: number; micro: number };
+export function parseSemVer(
+  s = "",
+): SemVer {
+  const m = s.match(/(\d+).(\d+).(\d+)/);
+  if (m) {
+    return {
+      major: parseInt(m[1]),
+      minor: parseInt(m[2]),
+      micro: parseInt(m[3]),
+    };
+  }
+  throw new Error(`'${s}' is not a semver value`);
+}
+export function compare(a: SemVer, b: SemVer): number {
+  if (a.major < b.major) return -1;
+  if (a.major > b.major) return 1;
+  if (a.minor < b.minor) return -1;
+  if (a.minor > b.minor) return 1;
+  if (a.micro < b.micro) return -1;
+  if (a.micro > b.micro) return 1;
+  return 0;
+}
+
+export const Feature = {
+  JS_KV: "js_kv",
+  JS_OBJECTSTORE: "js_objectstore",
+  JS_PULL_MAX_BYTES: "js_pull_max_bytes",
+  JS_NEW_CONSUMER_CREATE_API: "js_new_consumer_create",
+  JS_ALLOW_DIRECT: "js_allow_direct",
+  JS_MULTIPLE_CONSUMER_FILTER: "js_multiple_consumer_filter",
+  JS_SIMPLIFICATION: "js_simplification",
+  JS_STREAM_CONSUMER_METADATA: "js_stream_consumer_metadata",
+  JS_CONSUMER_FILTER_SUBJECTS: "js_consumer_filter_subjects",
+  JS_STREAM_FIRST_SEQ: "js_stream_first_seq",
+  JS_STREAM_SUBJECT_TRANSFORM: "js_stream_subject_transform",
+  JS_STREAM_SOURCE_SUBJECT_TRANSFORM: "js_stream_source_subject_transform",
+  JS_STREAM_COMPRESSION: "js_stream_compression",
+  JS_DEFAULT_CONSUMER_LIMITS: "js_default_consumer_limits",
+  JS_BATCH_DIRECT_GET: "js_batch_direct_get",
+  JS_PRIORITY_GROUPS: "js_priority_groups",
+  JS_CONSUMER_RESET: "js_consumer_reset",
+} as const;
+
+export type Feature = typeof Feature[keyof typeof Feature];
+
+type FeatureVersion = {
+  ok: boolean;
+  min: string;
+};
+
+export class Features {
+  server!: SemVer;
+  features: Map<string, FeatureVersion>;
+  disabled: string[];
+  constructor(v: SemVer) {
+    this.features = new Map<Feature, FeatureVersion>();
+    this.disabled = [];
+    this.update(v);
+  }
+
+  /**
+   * Removes all disabled entries
+   */
+  resetDisabled(): void {
+    this.disabled.length = 0;
+    this.update(this.server);
+  }
+
+  /**
+   * Disables a particular feature.
+   * @param f
+   */
+  disable(f: Feature): void {
+    this.disabled.push(f);
+    this.update(this.server);
+  }
+
+  isDisabled(f: Feature): boolean {
+    return this.disabled.indexOf(f) !== -1;
+  }
+
+  update(v: SemVer | string): void {
+    if (typeof v === "string") {
+      v = parseSemVer(v);
+    }
+    this.server = v;
+    this.set(Feature.JS_KV, "2.6.2");
+    this.set(Feature.JS_OBJECTSTORE, "2.6.3");
+    this.set(Feature.JS_PULL_MAX_BYTES, "2.8.3");
+    this.set(Feature.JS_NEW_CONSUMER_CREATE_API, "2.9.0");
+    this.set(Feature.JS_ALLOW_DIRECT, "2.9.0");
+    this.set(Feature.JS_MULTIPLE_CONSUMER_FILTER, "2.10.0");
+    this.set(Feature.JS_SIMPLIFICATION, "2.9.4");
+    this.set(Feature.JS_STREAM_CONSUMER_METADATA, "2.10.0");
+    this.set(Feature.JS_CONSUMER_FILTER_SUBJECTS, "2.10.0");
+    this.set(Feature.JS_STREAM_FIRST_SEQ, "2.10.0");
+    this.set(Feature.JS_STREAM_SUBJECT_TRANSFORM, "2.10.0");
+    this.set(Feature.JS_STREAM_SOURCE_SUBJECT_TRANSFORM, "2.10.0");
+    this.set(Feature.JS_STREAM_COMPRESSION, "2.10.0");
+    this.set(Feature.JS_DEFAULT_CONSUMER_LIMITS, "2.10.0");
+    this.set(Feature.JS_BATCH_DIRECT_GET, "2.11.0");
+    this.set(Feature.JS_PRIORITY_GROUPS, "2.11.0");
+    this.set(Feature.JS_CONSUMER_RESET, "2.14.0");
+
+    this.disabled.forEach((f) => {
+      this.features.delete(f);
+    });
+  }
+
+  /**
+   * Register a feature that requires a particular server version.
+   * @param f
+   * @param requires
+   */
+  set(f: Feature, requires: string): void {
+    this.features.set(f, {
+      min: requires,
+      ok: compare(this.server, parseSemVer(requires)) >= 0,
+    });
+  }
+
+  /**
+   * Returns whether the feature is available and the min server
+   * version that supports it.
+   * @param f
+   */
+  get(f: Feature): FeatureVersion {
+    return this.features.get(f) || { min: "unknown", ok: false };
+  }
+
+  /**
+   * Returns true if the feature is supported
+   * @param f
+   */
+  supports(f: Feature): boolean {
+    return this.get(f)?.ok || false;
+  }
+
+  /**
+   * Returns true if the server is at least the specified version
+   * @param v
+   */
+  require(v: SemVer | string): boolean {
+    if (typeof v === "string") {
+      v = parseSemVer(v);
+    }
+    return compare(this.server, v) >= 0;
+  }
+}