@nsshunt/ststestrunner 1.1.41 → 1.1.43

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,23 +1,19 @@
1
1
  import { AbstractRunnerExecutionWorker } from "@nsshunt/stsrunnerframework";
2
2
  import chalk from "chalk";
3
- import { STSAxiosConfig, Sleep, createAgentManager, defaultLogger, isNode } from "@nsshunt/stsutils";
3
+ import { STSAxiosConfig, Sleep, createAgentManager, isNode } from "@nsshunt/stsutils";
4
4
  import { FhirRESTClient, FhirSocketClientAllInOne, FhirSocketClientIndividual, createRetryAxiosClient } from "@nsshunt/stsfhirclient";
5
5
  import http from "node:http";
6
6
  import https from "node:https";
7
- import "lodash.clonedeep";
8
- import "axios";
9
- import "vue";
10
7
  import { SocketIoClient } from "@nsshunt/stssocketioutils";
11
8
  //#region \0rolldown/runtime.js
12
- var __defProp$1 = Object.defineProperty;
13
- var __commonJSMin$1 = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
9
+ var __defProp = Object.defineProperty;
14
10
  var __exportAll = (all, no_symbols) => {
15
11
  let target = {};
16
- for (var name in all) __defProp$1(target, name, {
12
+ for (var name in all) __defProp(target, name, {
17
13
  get: all[name],
18
14
  enumerable: true
19
15
  });
20
- if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
16
+ if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
21
17
  return target;
22
18
  };
23
19
  //#endregion
@@ -88,7 +84,7 @@ var TestCaseFhirBase = class {
88
84
  endpoint: fhirOptions.stsfhirserverendpoint,
89
85
  stsfhirapiroot: fhirOptions.stsfhirapiroot,
90
86
  stsfhirport: fhirOptions.stsfhirport,
91
- logger: defaultLogger,
87
+ logger: this.#runnerExecutionWorker.logger,
92
88
  agentManager: this.GetFhirAgentManager(),
93
89
  onRetryAttempt
94
90
  });
@@ -146,7 +142,7 @@ var TestCaseFhirBase = class {
146
142
  baseUrl: fhirOptions.stsfhirbaseurl,
147
143
  agentManager: this.GetFhirAgentManager(),
148
144
  joinRooms: [],
149
- logger: defaultLogger,
145
+ logger: this.#runnerExecutionWorker.logger,
150
146
  authToken: await this.GetAccessTokenForSocketClientAccess(),
151
147
  GetAccessToken: this.GetAccessToken
152
148
  };
@@ -35747,1331 +35743,123 @@ var ResourceDataGenerator = class {
35747
35743
  return this.#randomNameList[index.toString()];
35748
35744
  };
35749
35745
  };
35750
- (/* @__PURE__ */ __commonJSMin$1(((exports, module) => {
35751
- function E() {}
35752
- E.prototype = {
35753
- on: function(name, callback, ctx) {
35754
- var e = this.e || (this.e = {});
35755
- (e[name] || (e[name] = [])).push({
35756
- fn: callback,
35757
- ctx
35758
- });
35759
- return this;
35760
- },
35761
- once: function(name, callback, ctx) {
35762
- var self = this;
35763
- function listener() {
35764
- self.off(name, listener);
35765
- callback.apply(ctx, arguments);
35766
- }
35767
- listener._ = callback;
35768
- return this.on(name, listener, ctx);
35769
- },
35770
- emit: function(name) {
35771
- var data = [].slice.call(arguments, 1);
35772
- var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
35773
- var i = 0;
35774
- var len = evtArr.length;
35775
- for (; i < len; i++) evtArr[i].fn.apply(evtArr[i].ctx, data);
35776
- return this;
35777
- },
35778
- off: function(name, callback) {
35779
- var e = this.e || (this.e = {});
35780
- var evts = e[name];
35781
- var liveEvents = [];
35782
- if (evts && callback) {
35783
- for (var i = 0, len = evts.length; i < len; i++) if (evts[i].fn !== callback && evts[i].fn._ !== callback) liveEvents.push(evts[i]);
35784
- }
35785
- liveEvents.length ? e[name] = liveEvents : delete e[name];
35786
- return this;
35787
- }
35788
- };
35789
- module.exports = E;
35790
- module.exports.TinyEmitter = E;
35791
- })))();
35792
- var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
35793
- var Gauge = /* @__PURE__ */ function(Gauge) {
35794
- Gauge["ACTIVE_REQUEST_GAUGE"] = "a";
35795
- Gauge["AUTHENTICATION_COUNT_GAUGE"] = "b";
35796
- Gauge["AUTHENTICATION_ERROR_COUNT_GAUGE"] = "aa";
35797
- Gauge["AUTHENTICATION_RETRY_COUNT_GAUGE"] = "ab";
35798
- Gauge["CONNECTION_POOL_IDLE_GAUGE"] = "c";
35799
- Gauge["CONNECTION_POOL_TOTAL_GAUGE"] = "d";
35800
- Gauge["CONNECTION_POOL_WAITING_GAUGE"] = "e";
35801
- Gauge["CPU_LOAD_GAUGE"] = "f";
35802
- Gauge["CPU_SYSTEM_LOAD_GAUGE"] = "g";
35803
- Gauge["DURATION_GAUGE"] = "h";
35804
- Gauge["DURATION_HISTOGRAM_GAUGE"] = "i";
35805
- Gauge["ERROR_COUNT_GAUGE"] = "j";
35806
- Gauge["LATENCY_GAUGE"] = "k";
35807
- Gauge["LATENCY_HISTOGRAM_GAUGE"] = "l";
35808
- Gauge["LOGGER"] = "m";
35809
- Gauge["LOGGER_COPY"] = "n";
35810
- Gauge["NETWORK_RX_GAUGE"] = "o";
35811
- Gauge["NETWORK_TX_GAUGE"] = "p";
35812
- Gauge["REQUEST_COUNT_GAUGE"] = "q";
35813
- Gauge["RETRY_COUNT_GAUGE"] = "r";
35814
- Gauge["TIMER_GAUGE"] = "s";
35815
- Gauge["VELOCITY_GAUGE"] = "t";
35816
- Gauge["CONNECTION_COUNT_GAUGE"] = "u";
35817
- Gauge["OBJECT_GAUGE"] = "v";
35818
- Gauge["PAYLOAD_SIZE"] = "w";
35819
- Gauge["CORE_COUNT_GAUGE"] = "x";
35820
- Gauge["CHILD_COUNT"] = "y";
35821
- Gauge["UNKNOWN"] = "z";
35822
- return Gauge;
35823
- }({});
35824
- var GaugeTypes = /* @__PURE__ */ function(GaugeTypes) {
35825
- GaugeTypes["GAUGE_TYPE"] = "_";
35826
- GaugeTypes["INSTRUMENT_GAUGE"] = "a";
35827
- GaugeTypes["INSTRUMENT_VELOCITY"] = "b";
35828
- GaugeTypes["INSTRUMENT_HISTOGRAM"] = "c";
35829
- GaugeTypes["INSTRUMENT_LOG"] = "d";
35830
- GaugeTypes["INSTRUMENT_TIMER"] = "e";
35831
- GaugeTypes["INSTRUMENT_OBJECT"] = "f";
35832
- return GaugeTypes;
35833
- }({});
35834
- GaugeTypes.GAUGE_TYPE;
35835
- var require_timsort$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
35836
- /****
35837
- * The MIT License
35838
- *
35839
- * Copyright (c) 2015 Marco Ziccardi
35840
- *
35841
- * Permission is hereby granted, free of charge, to any person obtaining a copy
35842
- * of this software and associated documentation files (the "Software"), to deal
35843
- * in the Software without restriction, including without limitation the rights
35844
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
35845
- * copies of the Software, and to permit persons to whom the Software is
35846
- * furnished to do so, subject to the following conditions:
35847
- *
35848
- * The above copyright notice and this permission notice shall be included in
35849
- * all copies or substantial portions of the Software.
35850
- *
35851
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35852
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
35853
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
35854
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
35855
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
35856
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
35857
- * THE SOFTWARE.
35858
- *
35859
- ****/
35860
- (function(global, factory) {
35861
- if (typeof define === "function" && define.amd) define("timsort", ["exports"], factory);
35862
- else if (typeof exports !== "undefined") factory(exports);
35863
- else {
35864
- var mod = { exports: {} };
35865
- factory(mod.exports);
35866
- global.timsort = mod.exports;
35867
- }
35868
- })(exports, function(exports$1) {
35869
- "use strict";
35870
- exports$1.__esModule = true;
35871
- exports$1.sort = sort;
35872
- function _classCallCheck(instance, Constructor) {
35873
- if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
35874
- }
35875
- var DEFAULT_MIN_MERGE = 32;
35876
- var DEFAULT_MIN_GALLOPING = 7;
35877
- var DEFAULT_TMP_STORAGE_LENGTH = 256;
35878
- var POWERS_OF_TEN = [
35879
- 1,
35880
- 10,
35881
- 100,
35882
- 1e3,
35883
- 1e4,
35884
- 1e5,
35885
- 1e6,
35886
- 1e7,
35887
- 1e8,
35888
- 1e9
35889
- ];
35890
- function log10(x) {
35891
- if (x < 1e5) {
35892
- if (x < 100) return x < 10 ? 0 : 1;
35893
- if (x < 1e4) return x < 1e3 ? 2 : 3;
35894
- return 4;
35895
- }
35896
- if (x < 1e7) return x < 1e6 ? 5 : 6;
35897
- if (x < 1e9) return x < 1e8 ? 7 : 8;
35898
- return 9;
35899
- }
35900
- function alphabeticalCompare(a, b) {
35901
- if (a === b) return 0;
35902
- if (~~a === a && ~~b === b) {
35903
- if (a === 0 || b === 0) return a < b ? -1 : 1;
35904
- if (a < 0 || b < 0) {
35905
- if (b >= 0) return -1;
35906
- if (a >= 0) return 1;
35907
- a = -a;
35908
- b = -b;
35909
- }
35910
- var al = log10(a);
35911
- var bl = log10(b);
35912
- var t = 0;
35913
- if (al < bl) {
35914
- a *= POWERS_OF_TEN[bl - al - 1];
35915
- b /= 10;
35916
- t = -1;
35917
- } else if (al > bl) {
35918
- b *= POWERS_OF_TEN[al - bl - 1];
35919
- a /= 10;
35920
- t = 1;
35921
- }
35922
- if (a === b) return t;
35923
- return a < b ? -1 : 1;
35924
- }
35925
- var aStr = String(a);
35926
- var bStr = String(b);
35927
- if (aStr === bStr) return 0;
35928
- return aStr < bStr ? -1 : 1;
35929
- }
35930
- function minRunLength(n) {
35931
- var r = 0;
35932
- while (n >= DEFAULT_MIN_MERGE) {
35933
- r |= n & 1;
35934
- n >>= 1;
35935
- }
35936
- return n + r;
35937
- }
35938
- function makeAscendingRun(array, lo, hi, compare) {
35939
- var runHi = lo + 1;
35940
- if (runHi === hi) return 1;
35941
- if (compare(array[runHi++], array[lo]) < 0) {
35942
- while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) runHi++;
35943
- reverseRun(array, lo, runHi);
35944
- } else while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) runHi++;
35945
- return runHi - lo;
35946
- }
35947
- function reverseRun(array, lo, hi) {
35948
- hi--;
35949
- while (lo < hi) {
35950
- var t = array[lo];
35951
- array[lo++] = array[hi];
35952
- array[hi--] = t;
35953
- }
35954
- }
35955
- function binaryInsertionSort(array, lo, hi, start, compare) {
35956
- if (start === lo) start++;
35957
- for (; start < hi; start++) {
35958
- var pivot = array[start];
35959
- var left = lo;
35960
- var right = start;
35961
- while (left < right) {
35962
- var mid = left + right >>> 1;
35963
- if (compare(pivot, array[mid]) < 0) right = mid;
35964
- else left = mid + 1;
35965
- }
35966
- var n = start - left;
35967
- switch (n) {
35968
- case 3: array[left + 3] = array[left + 2];
35969
- case 2: array[left + 2] = array[left + 1];
35970
- case 1:
35971
- array[left + 1] = array[left];
35972
- break;
35973
- default: while (n > 0) {
35974
- array[left + n] = array[left + n - 1];
35975
- n--;
35976
- }
35977
- }
35978
- array[left] = pivot;
35979
- }
35980
- }
35981
- function gallopLeft(value, array, start, length, hint, compare) {
35982
- var lastOffset = 0;
35983
- var maxOffset = 0;
35984
- var offset = 1;
35985
- if (compare(value, array[start + hint]) > 0) {
35986
- maxOffset = length - hint;
35987
- while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
35988
- lastOffset = offset;
35989
- offset = (offset << 1) + 1;
35990
- if (offset <= 0) offset = maxOffset;
35991
- }
35992
- if (offset > maxOffset) offset = maxOffset;
35993
- lastOffset += hint;
35994
- offset += hint;
35995
- } else {
35996
- maxOffset = hint + 1;
35997
- while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
35998
- lastOffset = offset;
35999
- offset = (offset << 1) + 1;
36000
- if (offset <= 0) offset = maxOffset;
36001
- }
36002
- if (offset > maxOffset) offset = maxOffset;
36003
- var tmp = lastOffset;
36004
- lastOffset = hint - offset;
36005
- offset = hint - tmp;
36006
- }
36007
- lastOffset++;
36008
- while (lastOffset < offset) {
36009
- var m = lastOffset + (offset - lastOffset >>> 1);
36010
- if (compare(value, array[start + m]) > 0) lastOffset = m + 1;
36011
- else offset = m;
36012
- }
36013
- return offset;
36014
- }
36015
- function gallopRight(value, array, start, length, hint, compare) {
36016
- var lastOffset = 0;
36017
- var maxOffset = 0;
36018
- var offset = 1;
36019
- if (compare(value, array[start + hint]) < 0) {
36020
- maxOffset = hint + 1;
36021
- while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
36022
- lastOffset = offset;
36023
- offset = (offset << 1) + 1;
36024
- if (offset <= 0) offset = maxOffset;
36025
- }
36026
- if (offset > maxOffset) offset = maxOffset;
36027
- var tmp = lastOffset;
36028
- lastOffset = hint - offset;
36029
- offset = hint - tmp;
36030
- } else {
36031
- maxOffset = length - hint;
36032
- while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
36033
- lastOffset = offset;
36034
- offset = (offset << 1) + 1;
36035
- if (offset <= 0) offset = maxOffset;
36036
- }
36037
- if (offset > maxOffset) offset = maxOffset;
36038
- lastOffset += hint;
36039
- offset += hint;
36040
- }
36041
- lastOffset++;
36042
- while (lastOffset < offset) {
36043
- var m = lastOffset + (offset - lastOffset >>> 1);
36044
- if (compare(value, array[start + m]) < 0) offset = m;
36045
- else lastOffset = m + 1;
36046
- }
36047
- return offset;
36048
- }
36049
- var TimSort = (function() {
36050
- function TimSort(array, compare) {
36051
- _classCallCheck(this, TimSort);
36052
- this.array = null;
36053
- this.compare = null;
36054
- this.minGallop = DEFAULT_MIN_GALLOPING;
36055
- this.length = 0;
36056
- this.tmpStorageLength = DEFAULT_TMP_STORAGE_LENGTH;
36057
- this.stackLength = 0;
36058
- this.runStart = null;
36059
- this.runLength = null;
36060
- this.stackSize = 0;
36061
- this.array = array;
36062
- this.compare = compare;
36063
- this.length = array.length;
36064
- if (this.length < 2 * DEFAULT_TMP_STORAGE_LENGTH) this.tmpStorageLength = this.length >>> 1;
36065
- this.tmp = new Array(this.tmpStorageLength);
36066
- this.stackLength = this.length < 120 ? 5 : this.length < 1542 ? 10 : this.length < 119151 ? 19 : 40;
36067
- this.runStart = new Array(this.stackLength);
36068
- this.runLength = new Array(this.stackLength);
36069
- }
36070
- TimSort.prototype.pushRun = function pushRun(runStart, runLength) {
36071
- this.runStart[this.stackSize] = runStart;
36072
- this.runLength[this.stackSize] = runLength;
36073
- this.stackSize += 1;
36074
- };
36075
- TimSort.prototype.mergeRuns = function mergeRuns() {
36076
- while (this.stackSize > 1) {
36077
- var n = this.stackSize - 2;
36078
- if (n >= 1 && this.runLength[n - 1] <= this.runLength[n] + this.runLength[n + 1] || n >= 2 && this.runLength[n - 2] <= this.runLength[n] + this.runLength[n - 1]) {
36079
- if (this.runLength[n - 1] < this.runLength[n + 1]) n--;
36080
- } else if (this.runLength[n] > this.runLength[n + 1]) break;
36081
- this.mergeAt(n);
36082
- }
36083
- };
36084
- TimSort.prototype.forceMergeRuns = function forceMergeRuns() {
36085
- while (this.stackSize > 1) {
36086
- var n = this.stackSize - 2;
36087
- if (n > 0 && this.runLength[n - 1] < this.runLength[n + 1]) n--;
36088
- this.mergeAt(n);
36089
- }
36090
- };
36091
- TimSort.prototype.mergeAt = function mergeAt(i) {
36092
- var compare = this.compare;
36093
- var array = this.array;
36094
- var start1 = this.runStart[i];
36095
- var length1 = this.runLength[i];
36096
- var start2 = this.runStart[i + 1];
36097
- var length2 = this.runLength[i + 1];
36098
- this.runLength[i] = length1 + length2;
36099
- if (i === this.stackSize - 3) {
36100
- this.runStart[i + 1] = this.runStart[i + 2];
36101
- this.runLength[i + 1] = this.runLength[i + 2];
36102
- }
36103
- this.stackSize--;
36104
- var k = gallopRight(array[start2], array, start1, length1, 0, compare);
36105
- start1 += k;
36106
- length1 -= k;
36107
- if (length1 === 0) return;
36108
- length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
36109
- if (length2 === 0) return;
36110
- if (length1 <= length2) this.mergeLow(start1, length1, start2, length2);
36111
- else this.mergeHigh(start1, length1, start2, length2);
36112
- };
36113
- TimSort.prototype.mergeLow = function mergeLow(start1, length1, start2, length2) {
36114
- var compare = this.compare;
36115
- var array = this.array;
36116
- var tmp = this.tmp;
36117
- var i = 0;
36118
- for (i = 0; i < length1; i++) tmp[i] = array[start1 + i];
36119
- var cursor1 = 0;
36120
- var cursor2 = start2;
36121
- var dest = start1;
36122
- array[dest++] = array[cursor2++];
36123
- if (--length2 === 0) {
36124
- for (i = 0; i < length1; i++) array[dest + i] = tmp[cursor1 + i];
36125
- return;
36126
- }
36127
- if (length1 === 1) {
36128
- for (i = 0; i < length2; i++) array[dest + i] = array[cursor2 + i];
36129
- array[dest + length2] = tmp[cursor1];
36130
- return;
36131
- }
36132
- var minGallop = this.minGallop;
36133
- while (true) {
36134
- var count1 = 0;
36135
- var count2 = 0;
36136
- var exit = false;
36137
- do
36138
- if (compare(array[cursor2], tmp[cursor1]) < 0) {
36139
- array[dest++] = array[cursor2++];
36140
- count2++;
36141
- count1 = 0;
36142
- if (--length2 === 0) {
36143
- exit = true;
36144
- break;
36145
- }
36146
- } else {
36147
- array[dest++] = tmp[cursor1++];
36148
- count1++;
36149
- count2 = 0;
36150
- if (--length1 === 1) {
36151
- exit = true;
36152
- break;
36153
- }
36154
- }
36155
- while ((count1 | count2) < minGallop);
36156
- if (exit) break;
36157
- do {
36158
- count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
36159
- if (count1 !== 0) {
36160
- for (i = 0; i < count1; i++) array[dest + i] = tmp[cursor1 + i];
36161
- dest += count1;
36162
- cursor1 += count1;
36163
- length1 -= count1;
36164
- if (length1 <= 1) {
36165
- exit = true;
36166
- break;
36167
- }
36168
- }
36169
- array[dest++] = array[cursor2++];
36170
- if (--length2 === 0) {
36171
- exit = true;
36172
- break;
36173
- }
36174
- count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
36175
- if (count2 !== 0) {
36176
- for (i = 0; i < count2; i++) array[dest + i] = array[cursor2 + i];
36177
- dest += count2;
36178
- cursor2 += count2;
36179
- length2 -= count2;
36180
- if (length2 === 0) {
36181
- exit = true;
36182
- break;
36183
- }
36184
- }
36185
- array[dest++] = tmp[cursor1++];
36186
- if (--length1 === 1) {
36187
- exit = true;
36188
- break;
36189
- }
36190
- minGallop--;
36191
- } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
36192
- if (exit) break;
36193
- if (minGallop < 0) minGallop = 0;
36194
- minGallop += 2;
36195
- }
36196
- this.minGallop = minGallop;
36197
- if (minGallop < 1) this.minGallop = 1;
36198
- if (length1 === 1) {
36199
- for (i = 0; i < length2; i++) array[dest + i] = array[cursor2 + i];
36200
- array[dest + length2] = tmp[cursor1];
36201
- } else if (length1 === 0) throw new Error("mergeLow preconditions were not respected");
36202
- else for (i = 0; i < length1; i++) array[dest + i] = tmp[cursor1 + i];
36203
- };
36204
- TimSort.prototype.mergeHigh = function mergeHigh(start1, length1, start2, length2) {
36205
- var compare = this.compare;
36206
- var array = this.array;
36207
- var tmp = this.tmp;
36208
- var i = 0;
36209
- for (i = 0; i < length2; i++) tmp[i] = array[start2 + i];
36210
- var cursor1 = start1 + length1 - 1;
36211
- var cursor2 = length2 - 1;
36212
- var dest = start2 + length2 - 1;
36213
- var customCursor = 0;
36214
- var customDest = 0;
36215
- array[dest--] = array[cursor1--];
36216
- if (--length1 === 0) {
36217
- customCursor = dest - (length2 - 1);
36218
- for (i = 0; i < length2; i++) array[customCursor + i] = tmp[i];
36219
- return;
36220
- }
36221
- if (length2 === 1) {
36222
- dest -= length1;
36223
- cursor1 -= length1;
36224
- customDest = dest + 1;
36225
- customCursor = cursor1 + 1;
36226
- for (i = length1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
36227
- array[dest] = tmp[cursor2];
36228
- return;
36229
- }
36230
- var minGallop = this.minGallop;
36231
- while (true) {
36232
- var count1 = 0;
36233
- var count2 = 0;
36234
- var exit = false;
36235
- do
36236
- if (compare(tmp[cursor2], array[cursor1]) < 0) {
36237
- array[dest--] = array[cursor1--];
36238
- count1++;
36239
- count2 = 0;
36240
- if (--length1 === 0) {
36241
- exit = true;
36242
- break;
36243
- }
36244
- } else {
36245
- array[dest--] = tmp[cursor2--];
36246
- count2++;
36247
- count1 = 0;
36248
- if (--length2 === 1) {
36249
- exit = true;
36250
- break;
36251
- }
36252
- }
36253
- while ((count1 | count2) < minGallop);
36254
- if (exit) break;
36255
- do {
36256
- count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
36257
- if (count1 !== 0) {
36258
- dest -= count1;
36259
- cursor1 -= count1;
36260
- length1 -= count1;
36261
- customDest = dest + 1;
36262
- customCursor = cursor1 + 1;
36263
- for (i = count1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
36264
- if (length1 === 0) {
36265
- exit = true;
36266
- break;
36267
- }
36268
- }
36269
- array[dest--] = tmp[cursor2--];
36270
- if (--length2 === 1) {
36271
- exit = true;
36272
- break;
36273
- }
36274
- count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
36275
- if (count2 !== 0) {
36276
- dest -= count2;
36277
- cursor2 -= count2;
36278
- length2 -= count2;
36279
- customDest = dest + 1;
36280
- customCursor = cursor2 + 1;
36281
- for (i = 0; i < count2; i++) array[customDest + i] = tmp[customCursor + i];
36282
- if (length2 <= 1) {
36283
- exit = true;
36284
- break;
36285
- }
36286
- }
36287
- array[dest--] = array[cursor1--];
36288
- if (--length1 === 0) {
36289
- exit = true;
36290
- break;
36291
- }
36292
- minGallop--;
36293
- } while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
36294
- if (exit) break;
36295
- if (minGallop < 0) minGallop = 0;
36296
- minGallop += 2;
36297
- }
36298
- this.minGallop = minGallop;
36299
- if (minGallop < 1) this.minGallop = 1;
36300
- if (length2 === 1) {
36301
- dest -= length1;
36302
- cursor1 -= length1;
36303
- customDest = dest + 1;
36304
- customCursor = cursor1 + 1;
36305
- for (i = length1 - 1; i >= 0; i--) array[customDest + i] = array[customCursor + i];
36306
- array[dest] = tmp[cursor2];
36307
- } else if (length2 === 0) throw new Error("mergeHigh preconditions were not respected");
36308
- else {
36309
- customCursor = dest - (length2 - 1);
36310
- for (i = 0; i < length2; i++) array[customCursor + i] = tmp[i];
36311
- }
36312
- };
36313
- return TimSort;
36314
- })();
36315
- function sort(array, compare, lo, hi) {
36316
- if (!Array.isArray(array)) throw new TypeError("Can only sort arrays");
36317
- if (!compare) compare = alphabeticalCompare;
36318
- else if (typeof compare !== "function") {
36319
- hi = lo;
36320
- lo = compare;
36321
- compare = alphabeticalCompare;
36322
- }
36323
- if (!lo) lo = 0;
36324
- if (!hi) hi = array.length;
36325
- var remaining = hi - lo;
36326
- if (remaining < 2) return;
36327
- var runLength = 0;
36328
- if (remaining < DEFAULT_MIN_MERGE) {
36329
- runLength = makeAscendingRun(array, lo, hi, compare);
36330
- binaryInsertionSort(array, lo, hi, lo + runLength, compare);
36331
- return;
36332
- }
36333
- var ts = new TimSort(array, compare);
36334
- var minRun = minRunLength(remaining);
36335
- do {
36336
- runLength = makeAscendingRun(array, lo, hi, compare);
36337
- if (runLength < minRun) {
36338
- var force = remaining;
36339
- if (force > minRun) force = minRun;
36340
- binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
36341
- runLength = force;
36342
- }
36343
- ts.pushRun(lo, runLength);
36344
- ts.mergeRuns();
36345
- remaining -= runLength;
36346
- lo += runLength;
36347
- } while (remaining !== 0);
36348
- ts.forceMergeRuns();
36349
- }
36350
- });
36351
- }));
36352
- var require_timsort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
36353
- module.exports = require_timsort$1();
36354
- }));
36355
- var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
36356
- /**
36357
- @typedef {(Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array)} TypedArray
36358
- */
36359
- /**
36360
- * Error message for a case when percentile is less than 0.
36361
- *
36362
- * @param {Number} p
36363
- *
36364
- * @return {String}
36365
- */
36366
- function lessThanZeroError(p) {
36367
- return "Expect percentile to be >= 0 but given \"" + p + "\" and its type is \"" + typeof p + "\".";
36368
- }
36369
- /**
36370
- * Error message for a case when percentile is greater than 100.
36371
- *
36372
- * @param {Number} p
36373
- *
36374
- * @return {String}
36375
- */
36376
- function greaterThanHundredError(p) {
36377
- return "Expect percentile to be <= 100 but given \"" + p + "\" and its type is \"" + typeof p + "\".";
36378
- }
36379
- /**
36380
- * Error message for a case when percentile is not a number (NaN).
36381
- *
36382
- * @param {Number} p
36383
- *
36384
- * @return {String}
36385
- */
36386
- function nanError(p) {
36387
- return "Expect percentile to be a number but given \"" + p + "\" and its type is \"" + typeof p + "\".";
36388
- }
36389
- /**
36390
- * Checks that a list of percentiles are all numbers and they lie in range 0..100.
36391
- *
36392
- * @param {Array<Number>} ps - percentiles to calculate
36393
- *
36394
- * @return {Array} List of errors
36395
- */
36396
- function validateInput(ps) {
36397
- return ps.reduce(function(errors, p) {
36398
- if (isNaN(Number(p))) errors.push(nanError(p));
36399
- else if (p < 0) errors.push(lessThanZeroError(p));
36400
- else if (p > 100) errors.push(greaterThanHundredError(p));
36401
- return errors;
36402
- }, []);
36403
- }
36404
- /**
36405
- * Get percentile value from an array.
36406
- *
36407
- * @param {Number} p - percentile
36408
- * @param {Array|TypedArray} list - list of values
36409
- *
36410
- * @return {*}
36411
- */
36412
- function getPsValue(p, list) {
36413
- if (p === 0) return list[0];
36414
- return list[Math.ceil(list.length * (p / 100)) - 1];
36415
- }
36416
- /**
36417
- * Calculate percentile for given array of values.
36418
- *
36419
- * @template T
36420
- * @param {Number|Array<Number>} pOrPs - percentile or a list of percentiles
36421
- * @param {Array<T>|Array<Number>|TypedArray} list - array of values
36422
- * @param {function(T): Number} [fn] - optional function to extract a value from an array item
36423
- *
36424
- * @return {Number|T|Array<Number>|Array<T>}
36425
- */
36426
- function percentile(pOrPs, list, fn) {
36427
- var ps = Array.isArray(pOrPs) ? pOrPs : [pOrPs];
36428
- var validationErrors = validateInput(ps);
36429
- if (validationErrors.length) throw new Error(validationErrors.join(" "));
36430
- list = list.slice().sort(function(a, b) {
36431
- if (fn) {
36432
- a = fn(a);
36433
- b = fn(b);
36434
- }
36435
- a = Number.isNaN(a) ? Number.NEGATIVE_INFINITY : a;
36436
- b = Number.isNaN(b) ? Number.NEGATIVE_INFINITY : b;
36437
- if (a > b) return 1;
36438
- if (a < b) return -1;
36439
- return 0;
36440
- });
36441
- if (ps.length === 1) return getPsValue(ps[0], list);
36442
- return ps.map(function(p) {
36443
- return getPsValue(p, list);
36444
- });
36445
- }
36446
- module.exports = percentile;
36447
- }));
36448
- require_timsort();
36449
- require_lib();
36450
35746
  //#endregion
36451
- //#region node_modules/@nsshunt/stsinstrumentmanagerclient/dist/index.mjs
36452
- var SubscriptionTopic = /* @__PURE__ */ function(SubscriptionTopic) {
36453
- SubscriptionTopic["AllServicesCombined"] = "AllServicesCombined";
36454
- SubscriptionTopic["Services"] = "Services";
36455
- SubscriptionTopic["ServiceInstances"] = "ServiceInstances";
36456
- SubscriptionTopic["ServiceInstance"] = "ServiceInstance";
36457
- SubscriptionTopic["AllAgentsCombined"] = "AllAgentsCombined";
36458
- SubscriptionTopic["Agents"] = "Agents";
36459
- SubscriptionTopic["AgentWorkers"] = "AgentWorkers";
36460
- SubscriptionTopic["AgentWorker"] = "AgentWorker";
36461
- SubscriptionTopic["AllLambdasCombined"] = "AllLambdasCombined";
36462
- SubscriptionTopic["LambdaTechnologies"] = "LambdaTechnologies";
36463
- SubscriptionTopic["LambdaSubTechnologies"] = "LambdaSubTechnologies";
36464
- SubscriptionTopic["LambdaSubTechnologiesInstance"] = "LambdaSubTechnologiesInstance";
36465
- SubscriptionTopic["LogProcessing"] = "LogProcessing";
36466
- return SubscriptionTopic;
36467
- }({});
36468
- var ANSI_BACKGROUND_OFFSET = 10;
36469
- var wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
36470
- var wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
36471
- var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
36472
- var styles$1 = {
36473
- modifier: {
36474
- reset: [0, 0],
36475
- bold: [1, 22],
36476
- dim: [2, 22],
36477
- italic: [3, 23],
36478
- underline: [4, 24],
36479
- overline: [53, 55],
36480
- inverse: [7, 27],
36481
- hidden: [8, 28],
36482
- strikethrough: [9, 29]
36483
- },
36484
- color: {
36485
- black: [30, 39],
36486
- red: [31, 39],
36487
- green: [32, 39],
36488
- yellow: [33, 39],
36489
- blue: [34, 39],
36490
- magenta: [35, 39],
36491
- cyan: [36, 39],
36492
- white: [37, 39],
36493
- blackBright: [90, 39],
36494
- gray: [90, 39],
36495
- grey: [90, 39],
36496
- redBright: [91, 39],
36497
- greenBright: [92, 39],
36498
- yellowBright: [93, 39],
36499
- blueBright: [94, 39],
36500
- magentaBright: [95, 39],
36501
- cyanBright: [96, 39],
36502
- whiteBright: [97, 39]
36503
- },
36504
- bgColor: {
36505
- bgBlack: [40, 49],
36506
- bgRed: [41, 49],
36507
- bgGreen: [42, 49],
36508
- bgYellow: [43, 49],
36509
- bgBlue: [44, 49],
36510
- bgMagenta: [45, 49],
36511
- bgCyan: [46, 49],
36512
- bgWhite: [47, 49],
36513
- bgBlackBright: [100, 49],
36514
- bgGray: [100, 49],
36515
- bgGrey: [100, 49],
36516
- bgRedBright: [101, 49],
36517
- bgGreenBright: [102, 49],
36518
- bgYellowBright: [103, 49],
36519
- bgBlueBright: [104, 49],
36520
- bgMagentaBright: [105, 49],
36521
- bgCyanBright: [106, 49],
36522
- bgWhiteBright: [107, 49]
36523
- }
36524
- };
36525
- Object.keys(styles$1.modifier);
36526
- var foregroundColorNames = Object.keys(styles$1.color);
36527
- var backgroundColorNames = Object.keys(styles$1.bgColor);
36528
- [...foregroundColorNames, ...backgroundColorNames];
36529
- function assembleStyles() {
36530
- const codes = /* @__PURE__ */ new Map();
36531
- for (const [groupName, group] of Object.entries(styles$1)) {
36532
- for (const [styleName, style] of Object.entries(group)) {
36533
- styles$1[styleName] = {
36534
- open: `\u001B[${style[0]}m`,
36535
- close: `\u001B[${style[1]}m`
36536
- };
36537
- group[styleName] = styles$1[styleName];
36538
- codes.set(style[0], style[1]);
36539
- }
36540
- Object.defineProperty(styles$1, groupName, {
36541
- value: group,
36542
- enumerable: false
36543
- });
36544
- }
36545
- Object.defineProperty(styles$1, "codes", {
36546
- value: codes,
36547
- enumerable: false
36548
- });
36549
- styles$1.color.close = "\x1B[39m";
36550
- styles$1.bgColor.close = "\x1B[49m";
36551
- styles$1.color.ansi = wrapAnsi16();
36552
- styles$1.color.ansi256 = wrapAnsi256();
36553
- styles$1.color.ansi16m = wrapAnsi16m();
36554
- styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
36555
- styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
36556
- styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
36557
- Object.defineProperties(styles$1, {
36558
- rgbToAnsi256: {
36559
- value(red, green, blue) {
36560
- if (red === green && green === blue) {
36561
- if (red < 8) return 16;
36562
- if (red > 248) return 231;
36563
- return Math.round((red - 8) / 247 * 24) + 232;
36564
- }
36565
- return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
36566
- },
36567
- enumerable: false
36568
- },
36569
- hexToRgb: {
36570
- value(hex) {
36571
- const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
36572
- if (!matches) return [
36573
- 0,
36574
- 0,
36575
- 0
36576
- ];
36577
- let [colorString] = matches;
36578
- if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
36579
- const integer = Number.parseInt(colorString, 16);
36580
- return [
36581
- integer >> 16 & 255,
36582
- integer >> 8 & 255,
36583
- integer & 255
36584
- ];
36585
- },
36586
- enumerable: false
36587
- },
36588
- hexToAnsi256: {
36589
- value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
36590
- enumerable: false
36591
- },
36592
- ansi256ToAnsi: {
36593
- value(code) {
36594
- if (code < 8) return 30 + code;
36595
- if (code < 16) return 90 + (code - 8);
36596
- let red;
36597
- let green;
36598
- let blue;
36599
- if (code >= 232) {
36600
- red = ((code - 232) * 10 + 8) / 255;
36601
- green = red;
36602
- blue = red;
36603
- } else {
36604
- code -= 16;
36605
- const remainder = code % 36;
36606
- red = Math.floor(code / 36) / 5;
36607
- green = Math.floor(remainder / 6) / 5;
36608
- blue = remainder % 6 / 5;
36609
- }
36610
- const value = Math.max(red, green, blue) * 2;
36611
- if (value === 0) return 30;
36612
- let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
36613
- if (value === 2) result += 60;
36614
- return result;
36615
- },
36616
- enumerable: false
36617
- },
36618
- rgbToAnsi: {
36619
- value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
36620
- enumerable: false
36621
- },
36622
- hexToAnsi: {
36623
- value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
36624
- enumerable: false
36625
- }
36626
- });
36627
- return styles$1;
36628
- }
36629
- var ansiStyles = assembleStyles();
36630
- var level = (() => {
36631
- if (!("navigator" in globalThis)) return 0;
36632
- if (globalThis.navigator.userAgentData) {
36633
- const brand = navigator.userAgentData.brands.find(({ brand }) => brand === "Chromium");
36634
- if (brand && brand.version > 93) return 3;
36635
- }
36636
- if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) return 1;
36637
- return 0;
36638
- })();
36639
- var colorSupport = level !== 0 && {
36640
- level,
36641
- hasBasic: true,
36642
- has256: level >= 2,
36643
- has16m: level >= 3
36644
- };
36645
- var supportsColor = {
36646
- stdout: colorSupport,
36647
- stderr: colorSupport
36648
- };
36649
- function stringReplaceAll(string, substring, replacer) {
36650
- let index = string.indexOf(substring);
36651
- if (index === -1) return string;
36652
- const substringLength = substring.length;
36653
- let endIndex = 0;
36654
- let returnValue = "";
36655
- do {
36656
- returnValue += string.slice(endIndex, index) + substring + replacer;
36657
- endIndex = index + substringLength;
36658
- index = string.indexOf(substring, endIndex);
36659
- } while (index !== -1);
36660
- returnValue += string.slice(endIndex);
36661
- return returnValue;
36662
- }
36663
- function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
36664
- let endIndex = 0;
36665
- let returnValue = "";
36666
- do {
36667
- const gotCR = string[index - 1] === "\r";
36668
- returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
36669
- endIndex = index + 1;
36670
- index = string.indexOf("\n", endIndex);
36671
- } while (index !== -1);
36672
- returnValue += string.slice(endIndex);
36673
- return returnValue;
36674
- }
36675
- var { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
36676
- var GENERATOR = Symbol("GENERATOR");
36677
- var STYLER = Symbol("STYLER");
36678
- var IS_EMPTY = Symbol("IS_EMPTY");
36679
- var levelMapping = [
36680
- "ansi",
36681
- "ansi",
36682
- "ansi256",
36683
- "ansi16m"
36684
- ];
36685
- var styles = Object.create(null);
36686
- var applyOptions = (object, options = {}) => {
36687
- if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
36688
- const colorLevel = stdoutColor ? stdoutColor.level : 0;
36689
- object.level = options.level === void 0 ? colorLevel : options.level;
36690
- };
36691
- var chalkFactory = (options) => {
36692
- const chalk = (...strings) => strings.join(" ");
36693
- applyOptions(chalk, options);
36694
- Object.setPrototypeOf(chalk, createChalk.prototype);
36695
- return chalk;
36696
- };
36697
- function createChalk(options) {
36698
- return chalkFactory(options);
36699
- }
36700
- Object.setPrototypeOf(createChalk.prototype, Function.prototype);
36701
- for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
36702
- const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
36703
- Object.defineProperty(this, styleName, { value: builder });
36704
- return builder;
36705
- } };
36706
- styles.visible = { get() {
36707
- const builder = createBuilder(this, this[STYLER], true);
36708
- Object.defineProperty(this, "visible", { value: builder });
36709
- return builder;
36710
- } };
36711
- var getModelAnsi = (model, level, type, ...arguments_) => {
36712
- if (model === "rgb") {
36713
- if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
36714
- if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
36715
- return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
36716
- }
36717
- if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
36718
- return ansiStyles[type][model](...arguments_);
36719
- };
36720
- for (const model of [
36721
- "rgb",
36722
- "hex",
36723
- "ansi256"
36724
- ]) {
36725
- styles[model] = { get() {
36726
- const { level } = this;
36727
- return function(...arguments_) {
36728
- const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
36729
- return createBuilder(this, styler, this[IS_EMPTY]);
36730
- };
36731
- } };
36732
- const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
36733
- styles[bgModel] = { get() {
36734
- const { level } = this;
36735
- return function(...arguments_) {
36736
- const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
36737
- return createBuilder(this, styler, this[IS_EMPTY]);
36738
- };
36739
- } };
36740
- }
36741
- var proto = Object.defineProperties(() => {}, {
36742
- ...styles,
36743
- level: {
36744
- enumerable: true,
36745
- get() {
36746
- return this[GENERATOR].level;
36747
- },
36748
- set(level) {
36749
- this[GENERATOR].level = level;
36750
- }
36751
- }
36752
- });
36753
- var createStyler = (open, close, parent) => {
36754
- let openAll;
36755
- let closeAll;
36756
- if (parent === void 0) {
36757
- openAll = open;
36758
- closeAll = close;
36759
- } else {
36760
- openAll = parent.openAll + open;
36761
- closeAll = close + parent.closeAll;
36762
- }
36763
- return {
36764
- open,
36765
- close,
36766
- openAll,
36767
- closeAll,
36768
- parent
36769
- };
36770
- };
36771
- var createBuilder = (self, _styler, _isEmpty) => {
36772
- const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
36773
- Object.setPrototypeOf(builder, proto);
36774
- builder[GENERATOR] = self;
36775
- builder[STYLER] = _styler;
36776
- builder[IS_EMPTY] = _isEmpty;
36777
- return builder;
36778
- };
36779
- var applyStyle = (self, string) => {
36780
- if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
36781
- let styler = self[STYLER];
36782
- if (styler === void 0) return string;
36783
- const { openAll, closeAll } = styler;
36784
- if (string.includes("\x1B")) while (styler !== void 0) {
36785
- string = stringReplaceAll(string, styler.close, styler.open);
36786
- styler = styler.parent;
36787
- }
36788
- const lfIndex = string.indexOf("\n");
36789
- if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
36790
- return openAll + string + closeAll;
36791
- };
36792
- Object.defineProperties(createChalk.prototype, styles);
36793
- var chalk$1 = createChalk();
36794
- createChalk({ level: stderrColor ? stderrColor.level : 0 });
36795
- new TextEncoder();
36796
- new TextDecoder();
36797
- /**
36798
- * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
36799
- */
36800
- var ExtData = class {
36801
- type;
36802
- data;
36803
- constructor(type, data) {
36804
- this.type = type;
36805
- this.data = data;
36806
- }
36807
- };
36808
- var DecodeError = class DecodeError extends Error {
36809
- constructor(message) {
36810
- super(message);
36811
- const proto = Object.create(DecodeError.prototype);
36812
- Object.setPrototypeOf(this, proto);
36813
- Object.defineProperty(this, "name", {
36814
- configurable: true,
36815
- enumerable: false,
36816
- value: DecodeError.name
36817
- });
36818
- }
36819
- };
36820
- function setInt64(view, offset, value) {
36821
- const high = Math.floor(value / 4294967296);
36822
- const low = value;
36823
- view.setUint32(offset, high);
36824
- view.setUint32(offset + 4, low);
36825
- }
36826
- function getInt64(view, offset) {
36827
- const high = view.getInt32(offset);
36828
- const low = view.getUint32(offset + 4);
36829
- return high * 4294967296 + low;
36830
- }
36831
- var TIMESTAMP32_MAX_SEC = 4294967295;
36832
- var TIMESTAMP64_MAX_SEC = 17179869183;
36833
- function encodeTimeSpecToTimestamp({ sec, nsec }) {
36834
- if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
36835
- const rv = new Uint8Array(4);
36836
- new DataView(rv.buffer).setUint32(0, sec);
36837
- return rv;
36838
- } else {
36839
- const secHigh = sec / 4294967296;
36840
- const secLow = sec & 4294967295;
36841
- const rv = new Uint8Array(8);
36842
- const view = new DataView(rv.buffer);
36843
- view.setUint32(0, nsec << 2 | secHigh & 3);
36844
- view.setUint32(4, secLow);
36845
- return rv;
36846
- }
36847
- else {
36848
- const rv = new Uint8Array(12);
36849
- const view = new DataView(rv.buffer);
36850
- view.setUint32(0, nsec);
36851
- setInt64(view, 4, sec);
36852
- return rv;
36853
- }
36854
- }
36855
- function encodeDateToTimeSpec(date) {
36856
- const msec = date.getTime();
36857
- const sec = Math.floor(msec / 1e3);
36858
- const nsec = (msec - sec * 1e3) * 1e6;
36859
- const nsecInSec = Math.floor(nsec / 1e9);
36860
- return {
36861
- sec: sec + nsecInSec,
36862
- nsec: nsec - nsecInSec * 1e9
36863
- };
36864
- }
36865
- function encodeTimestampExtension(object) {
36866
- if (object instanceof Date) return encodeTimeSpecToTimestamp(encodeDateToTimeSpec(object));
36867
- else return null;
36868
- }
36869
- function decodeTimestampToTimeSpec(data) {
36870
- const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
36871
- switch (data.byteLength) {
36872
- case 4: return {
36873
- sec: view.getUint32(0),
36874
- nsec: 0
36875
- };
36876
- case 8: {
36877
- const nsec30AndSecHigh2 = view.getUint32(0);
36878
- const secLow32 = view.getUint32(4);
36879
- return {
36880
- sec: (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32,
36881
- nsec: nsec30AndSecHigh2 >>> 2
36882
- };
36883
- }
36884
- case 12: return {
36885
- sec: getInt64(view, 4),
36886
- nsec: view.getUint32(0)
36887
- };
36888
- default: throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
36889
- }
36890
- }
36891
- function decodeTimestampExtension(data) {
36892
- const timeSpec = decodeTimestampToTimeSpec(data);
36893
- return /* @__PURE__ */ new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
36894
- }
36895
- var timestampExtension = {
36896
- type: -1,
36897
- encode: encodeTimestampExtension,
36898
- decode: decodeTimestampExtension
36899
- };
36900
- (class ExtensionCodec {
36901
- static defaultCodec = new ExtensionCodec();
36902
- __brand;
36903
- builtInEncoders = [];
36904
- builtInDecoders = [];
36905
- encoders = [];
36906
- decoders = [];
36907
- constructor() {
36908
- this.register(timestampExtension);
36909
- }
36910
- register({ type, encode, decode }) {
36911
- if (type >= 0) {
36912
- this.encoders[type] = encode;
36913
- this.decoders[type] = decode;
36914
- } else {
36915
- const index = -1 - type;
36916
- this.builtInEncoders[index] = encode;
36917
- this.builtInDecoders[index] = decode;
36918
- }
36919
- }
36920
- tryToEncode(object, context) {
36921
- for (let i = 0; i < this.builtInEncoders.length; i++) {
36922
- const encodeExt = this.builtInEncoders[i];
36923
- if (encodeExt != null) {
36924
- const data = encodeExt(object, context);
36925
- if (data != null) return new ExtData(-1 - i, data);
36926
- }
36927
- }
36928
- for (let i = 0; i < this.encoders.length; i++) {
36929
- const encodeExt = this.encoders[i];
36930
- if (encodeExt != null) {
36931
- const data = encodeExt(object, context);
36932
- if (data != null) return new ExtData(i, data);
36933
- }
36934
- }
36935
- if (object instanceof ExtData) return object;
36936
- return null;
36937
- }
36938
- decode(data, type, context) {
36939
- const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
36940
- if (decodeExt) return decodeExt(data, type, context);
36941
- else return new ExtData(type, data);
36942
- }
36943
- });
36944
- var influxDBDataType = /* @__PURE__ */ function(influxDBDataType) {
36945
- influxDBDataType["intField"] = "intField";
36946
- influxDBDataType["floatField"] = "floatField";
36947
- influxDBDataType["stringField"] = "stringField";
36948
- return influxDBDataType;
36949
- }({});
36950
- Gauge.REQUEST_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.ERROR_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.RETRY_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.VELOCITY_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.ACTIVE_REQUEST_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CORE_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.NETWORK_RX_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.NETWORK_TX_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_VELOCITY, Gauge.TIMER_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_TIMER, Gauge.DURATION_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.DURATION_HISTOGRAM_GAUGE, Gauge.LATENCY_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.LATENCY_HISTOGRAM_GAUGE, Gauge.LOGGER, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_LOG, Gauge.CPU_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_TOTAL_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_IDLE_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_WAITING_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CPU_SYSTEM_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.OBJECT_GAUGE, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_OBJECT, SubscriptionTopic.AllServicesCombined, SubscriptionTopic.Services, SubscriptionTopic.ServiceInstances, SubscriptionTopic.ServiceInstance, Gauge.CHILD_COUNT, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, SubscriptionTopic.AllAgentsCombined, SubscriptionTopic.Agents, SubscriptionTopic.AgentWorkers, SubscriptionTopic.AgentWorker, Gauge.CPU_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_COUNT_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_TOTAL_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_IDLE_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CONNECTION_POOL_WAITING_GAUGE, influxDBDataType.intField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.CPU_SYSTEM_LOAD_GAUGE, influxDBDataType.floatField, GaugeTypes.INSTRUMENT_GAUGE, Gauge.OBJECT_GAUGE, influxDBDataType.stringField, GaugeTypes.INSTRUMENT_OBJECT, SubscriptionTopic.AllLambdasCombined, SubscriptionTopic.LambdaTechnologies, SubscriptionTopic.LambdaSubTechnologies, SubscriptionTopic.LambdaSubTechnologiesInstance;
36951
- var SOCKET_NAMESPACE = "stsinstrumentmanager/stsmonitor";
36952
- var SocketBrowserClientLogPublisher = class extends SocketIoClient {
35747
+ //#region src/libmodule/workerTestCaseLogPublisher.ts
35748
+ var WorkerTestCaseLogPublisher = class extends SocketIoClient {
36953
35749
  #id;
36954
35750
  #options;
36955
35751
  constructor(options) {
36956
- super("stsinstrumentmanagerclient:SocketBrowserClientLogPublisher");
35752
+ super("ststestrunner:SocketClientLogPublisher");
35753
+ this.#id = crypto.randomUUID();
36957
35754
  this.#options = options;
36958
- this.#id = globalThis.crypto.randomUUID();
36959
- this.LogDebugMessage(chalk$1.cyan(`${this.logPrefix}Start()`));
36960
- const url = `${this.#options.imendpoint}:${this.#options.import}/${SOCKET_NAMESPACE}/`;
36961
- this.LogDebugMessage(chalk$1.cyan(`${this.logPrefix}SetupSocket() url: [${url}]`));
36962
- this.WithAddress(url).WithLogger(defaultLogger).SetupSocket();
36963
35755
  }
35756
+ Start = (im_endpoint, im_port, im_namespace) => {
35757
+ this.LogDebugMessage(chalk.cyan(`${this.logPrefix}Start()`));
35758
+ const url = `${im_endpoint}:${im_port}/${im_namespace}/`;
35759
+ this.LogDebugMessage(chalk.cyan(`${this.logPrefix}SetupSocket() url: [${url}]`));
35760
+ this.WithAddress(url).WithLogger(this.#options.logger).SetupSocket();
35761
+ };
36964
35762
  get id() {
36965
35763
  return this.#id;
36966
35764
  }
36967
35765
  get logPrefix() {
36968
- return `stsinstrumentmanagerclient:SocketBrowserClientLogPublisher:`;
35766
+ return `ststestrunner:SocketClientLogPublisher:`;
36969
35767
  }
36970
35768
  SocketConnect(socket) {
36971
- this.LogDebugMessage(chalk$1.magenta(`${this.logPrefix}SocketConnect(): Socket ID: [${socket.id}], Joining Room: [${this.#options.rooms}]`));
35769
+ this.LogDebugMessage(chalk.magenta(`${this.logPrefix}SocketConnect(): Socket ID: [${socket.id}], Joining Room: [${this.#options.rooms}]`));
36972
35770
  socket.emit("__STSjoinRoom", this.#options.rooms);
36973
35771
  }
36974
35772
  SocketError(error) {
36975
- this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketError(): Error: [${error}]`));
35773
+ this.LogErrorMessage(chalk.red(`${this.logPrefix}SocketError(): Error: [${error}]`));
36976
35774
  }
36977
35775
  SetupSocketEvents(socket) {
36978
- this.LogDebugMessage(chalk$1.magenta(`${this.logPrefix}SetupSocketEvents(): Socket ID: [${socket.id}]`));
35776
+ this.LogDebugMessage(chalk.magenta(`${this.logPrefix}SetupSocketEvents(): Socket ID: [${socket.id}]`));
36979
35777
  }
36980
35778
  SocketConnectError(error) {
36981
- this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketConnectError(): Error: [${error}]`));
35779
+ this.LogErrorMessage(chalk.red(`${this.logPrefix}SocketConnectError(): Error: [${error}]`));
36982
35780
  }
36983
35781
  SocketDisconnect(reason) {
36984
- this.LogErrorMessage(chalk$1.red(`${this.logPrefix}SocketDisconnect(): reason: [${reason}]`));
35782
+ this.LogErrorMessage(chalk.red(`${this.logPrefix}SocketDisconnect(): reason: [${reason}]`));
36985
35783
  }
36986
35784
  };
36987
- var STSLoggerSocket = class {
35785
+ //#endregion
35786
+ //#region src/libmodule/workerTestCaseLogger.ts
35787
+ var WorkerTestCaseLogger = class {
36988
35788
  #options;
36989
35789
  #socketIoClient;
36990
35790
  constructor(opts) {
36991
35791
  this.#options = opts;
36992
- this.#socketIoClient = new SocketBrowserClientLogPublisher({
35792
+ this.#socketIoClient = new WorkerTestCaseLogPublisher({
36993
35793
  rooms: this.#options.rooms,
36994
- imendpoint: this.#options.imendpoint,
36995
- import: this.#options.import
35794
+ logger: this
36996
35795
  });
36997
- this.#socketIoClient.socket?.emit("__STSjoinRoom", this.#options.rooms);
35796
+ this.#socketIoClient.Start(opts.imendpoint, opts.import, opts.imsocketnamespace);
36998
35797
  }
36999
- JoinRoom = () => {
37000
- this.#socketIoClient.socket?.emit("__STSjoinRoom", this.#options.rooms);
35798
+ UsePrefix = (message) => {
35799
+ return `[][] ==>> ${message}`;
37001
35800
  };
37002
- error(message) {
37003
- this.#log({
37004
- level: "error",
37005
- message
37006
- });
37007
- }
37008
- warn(message) {
37009
- this.#log({
37010
- level: "warn",
37011
- message
37012
- });
37013
- }
37014
- info(message) {
37015
- this.#log({
37016
- level: "info",
37017
- message
37018
- });
37019
- }
37020
- http(message) {
37021
- this.#log({
37022
- level: "http",
37023
- message
37024
- });
37025
- }
37026
- verbose(message) {
37027
- this.#log({
37028
- level: "verbose",
37029
- message
37030
- });
37031
- }
37032
- debug(message) {
37033
- this.#log({
37034
- level: "debug",
37035
- message
37036
- });
37037
- }
37038
- silly(message) {
37039
- this.#log({
37040
- level: "silly",
37041
- message
37042
- });
37043
- }
37044
- #log(info) {
35801
+ error = (message) => {
35802
+ this.log(0, message);
35803
+ this.#options.additionalLogger.error(this.UsePrefix(message));
35804
+ };
35805
+ warn = (message) => {
35806
+ this.log(1, message);
35807
+ this.#options.additionalLogger.warn(this.UsePrefix(message));
35808
+ };
35809
+ info = (message) => {
35810
+ this.log(2, message);
35811
+ this.#options.additionalLogger.info(this.UsePrefix(message));
35812
+ };
35813
+ http = (message) => {
35814
+ this.log(3, message);
35815
+ this.#options.additionalLogger.http(this.UsePrefix(message));
35816
+ };
35817
+ verbose = (message) => {
35818
+ this.log(4, message);
35819
+ this.#options.additionalLogger.verbose(this.UsePrefix(message));
35820
+ };
35821
+ debug = (message) => {
35822
+ this.log(5, message);
35823
+ this.#options.additionalLogger.debug(this.UsePrefix(message));
35824
+ };
35825
+ silly = (message) => {
35826
+ this.log(6, message);
35827
+ this.#options.additionalLogger.silly(this.UsePrefix(message));
35828
+ };
35829
+ log = (level, message) => {
37045
35830
  this.#socketIoClient.socket?.emit("__STSsendToRoom", this.#options.rooms, {
37046
35831
  command: "logmessage",
37047
35832
  payload: {
37048
- level: info.level,
37049
- message: info.message,
35833
+ level,
35834
+ message,
37050
35835
  dateTime: Date.now()
37051
35836
  }
37052
35837
  });
37053
- }
35838
+ };
37054
35839
  };
37055
35840
  //#endregion
37056
35841
  //#region src/libmodule/workerFhirTestCases.ts
37057
35842
  var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
35843
+ _options;
37058
35844
  _resourceDataGenerator;
37059
- _logRoom = `logs_workerTestCase`;
37060
- _loggerSocket;
37061
- constructor() {
35845
+ _workerTestCaseLogger;
35846
+ constructor(options) {
37062
35847
  super();
35848
+ this._options = options;
37063
35849
  this._resourceDataGenerator = new ResourceDataGenerator();
37064
- this._loggerSocket = new STSLoggerSocket({
37065
- imendpoint: "https://stscore.stsmda.org",
37066
- import: "3001",
37067
- rooms: [this._logRoom]
35850
+ this._workerTestCaseLogger = new WorkerTestCaseLogger({
35851
+ additionalLogger: this._options.additionalLogger,
35852
+ imendpoint: this._options.imendpoint,
35853
+ import: this._options.import,
35854
+ imsocketnamespace: this._options.imsocketnamespace,
35855
+ rooms: [...this._options.rooms]
37068
35856
  });
37069
35857
  }
37070
35858
  get resourceDataGenerator() {
37071
35859
  return this._resourceDataGenerator;
37072
35860
  }
37073
35861
  get logger() {
37074
- return this._loggerSocket;
35862
+ return this._workerTestCaseLogger;
37075
35863
  }
37076
35864
  CreateAsyncRunner = async (testRunnerTelemetryPayload) => {
37077
35865
  return AsyncRunnerFactory.CreateAsyncRunner(this, testRunnerTelemetryPayload);