mavenagi 1.0.7 → 1.0.9

package/core/schemas/utils/createIdentitySchemaCreator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIdentitySchemaCreator = void 0;
+exports.createIdentitySchemaCreator = createIdentitySchemaCreator;
 const schema_utils_1 = require("../builders/schema-utils");
 const maybeSkipValidation_1 = require("./maybeSkipValidation");
 function createIdentitySchemaCreator(schemaType, validate) {
@@ -13,4 +13,3 @@ function createIdentitySchemaCreator(schemaType, validate) {
         return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
     };
 }
-exports.createIdentitySchemaCreator = createIdentitySchemaCreator;

package/core/schemas/utils/entries.d.ts

@@ -1 +1 @@
-export declare function entries<T>(object: T): [keyof T, T[keyof T]][];
+export declare function entries<T extends object>(object: T): [keyof T, T[keyof T]][];

package/core/schemas/utils/entries.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entries = void 0;
+exports.entries = entries;
 function entries(object) {
     return Object.entries(object);
 }
-exports.entries = entries;

package/core/schemas/utils/filterObject.d.ts

@@ -1 +1 @@
-export declare function filterObject<T, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;
+export declare function filterObject<T extends object, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;

package/core/schemas/utils/filterObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterObject = void 0;
+exports.filterObject = filterObject;
 function filterObject(obj, keysToInclude) {
     const keysToIncludeSet = new Set(keysToInclude);
     return Object.entries(obj).reduce((acc, [key, value]) => {
@@ -11,4 +11,3 @@ function filterObject(obj, keysToInclude) {
         // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
     }, {});
 }
-exports.filterObject = filterObject;

package/core/schemas/utils/getErrorMessageForIncorrectType.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageForIncorrectType = void 0;
+exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getErrorMessageForIncorrectType(value, expectedType) {
     return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
 }
-exports.getErrorMessageForIncorrectType = getErrorMessageForIncorrectType;
 function getTypeAsString(value) {
     if (Array.isArray(value)) {
         return "list";

package/core/schemas/utils/isPlainObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPlainObject = void 0;
+exports.isPlainObject = isPlainObject;
 // borrowed from https://github.com/lodash/lodash/blob/master/isPlainObject.js
 function isPlainObject(value) {
     if (typeof value !== "object" || value === null) {
@@ -15,4 +15,3 @@ function isPlainObject(value) {
     }
     return Object.getPrototypeOf(value) === proto;
 }
-exports.isPlainObject = isPlainObject;

package/core/schemas/utils/keys.d.ts

@@ -1 +1 @@
-export declare function keys<T>(object: T): (keyof T)[];
+export declare function keys<T extends object>(object: T): (keyof T)[];

package/core/schemas/utils/keys.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keys = void 0;
+exports.keys = keys;
 function keys(object) {
     return Object.keys(object);
 }
-exports.keys = keys;

package/core/schemas/utils/maybeSkipValidation.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeSkipValidation = void 0;
+exports.maybeSkipValidation = maybeSkipValidation;
 function maybeSkipValidation(schema) {
     return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
 }
-exports.maybeSkipValidation = maybeSkipValidation;
 function transformAndMaybeSkipValidation(transform) {
     return (value, opts) => {
         const transformed = transform(value, opts);

package/core/schemas/utils/partition.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.partition = void 0;
+exports.partition = partition;
 function partition(items, predicate) {
     const trueItems = [], falseItems = [];
     for (const item of items) {
@@ -13,4 +13,3 @@ function partition(items, predicate) {
     }
     return [trueItems, falseItems];
 }
-exports.partition = partition;

package/core/streaming-fetcher/Stream.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Readable } from "stream";
 export declare namespace Stream {
     interface Args {

package/core/streaming-fetcher/Stream.js

@@ -19,8 +19,9 @@ var __await = (this && this.__await) || function (v) { return this instanceof __
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
     function fulfill(value) { resume("next", value); }
@@ -28,7 +29,8 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readableStreamAsyncIterable = exports.Stream = void 0;
+exports.Stream = void 0;
+exports.readableStreamAsyncIterable = readableStreamAsyncIterable;
 const runtime_1 = require("../runtime");
 const DATA_PREFIX = "data:";
 class Stream {
@@ -48,26 +50,24 @@ class Stream {
     }
     iterMessages() {
         return __asyncGenerator(this, arguments, function* iterMessages_1() {
-            var e_1, _a;
+            var _a, e_1, _b, _c;
             this.controller.signal;
             const stream = readableStreamAsyncIterable(this.stream);
             let buf = "";
             let prefixSeen = false;
             try {
-                for (var stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield __await(stream_1.next()), !stream_1_1.done;) {
-                    const chunk = stream_1_1.value;
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _a = stream_1_1.done, !_a; _d = true) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    const chunk = _c;
                     buf += this.decodeChunk(chunk);
                     let terminatorIndex;
-                    // Parse the chunk into as many messages as possible
                     while ((terminatorIndex = buf.indexOf(this.messageTerminator)) >= 0) {
-                        // Extract the line from the buffer
                         let line = buf.slice(0, terminatorIndex + 1);
-                        buf = buf.slice(terminatorIndex + 1);
-                        // Skip empty lines
-                        if (line.length === 0) {
+                        buf = buf.slice(terminatorIndex + this.messageTerminator.length);
+                        if (!line.trim()) {
                             continue;
                         }
-                        // Skip the chunk until the prefix is found
                         if (!prefixSeen && this.prefix != null) {
                             const prefixIndex = line.indexOf(this.prefix);
                             if (prefixIndex === -1) {
@@ -76,11 +76,9 @@ class Stream {
                             prefixSeen = true;
                             line = line.slice(prefixIndex + this.prefix.length);
                         }
-                        // If the stream terminator is present, return
                         if (this.streamTerminator != null && line.includes(this.streamTerminator)) {
                             return yield __await(void 0);
                         }
-                        // Otherwise, yield message from the prefix to the terminator
                         const message = yield __await(this.parse(JSON.parse(line)));
                         yield yield __await(message);
                         prefixSeen = false;
@@ -90,7 +88,7 @@ class Stream {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (stream_1_1 && !stream_1_1.done && (_a = stream_1.return)) yield __await(_a.call(stream_1));
+                    if (!_d && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -98,17 +96,19 @@ class Stream {
     }
     [Symbol.asyncIterator]() {
         return __asyncGenerator(this, arguments, function* _a() {
-            var e_2, _b;
+            var _b, e_2, _c, _d;
             try {
-                for (var _c = __asyncValues(this.iterMessages()), _d; _d = yield __await(_c.next()), !_d.done;) {
-                    const message = _d.value;
+                for (var _e = true, _f = __asyncValues(this.iterMessages()), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+                    _d = _g.value;
+                    _e = false;
+                    const message = _d;
                     yield yield __await(message);
                 }
             }
             catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_b = _c.return)) yield __await(_b.call(_c));
+                    if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
                 }
                 finally { if (e_2) throw e_2.error; }
             }
@@ -122,7 +122,7 @@ class Stream {
             decoded += decoder.decode(chunk);
         }
         // Buffer is present in Node.js environment
-        else if (runtime_1.RUNTIME.type === "node" && typeof chunk != "undefined") {
+        else if (runtime_1.RUNTIME.type === "node" && typeof chunk !== "undefined") {
             decoded += Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
         }
         return decoded;
@@ -167,4 +167,3 @@ function readableStreamAsyncIterable(stream) {
         },
     };
 }
-exports.readableStreamAsyncIterable = readableStreamAsyncIterable;

package/core/websocket/events.d.ts

@@ -0,0 +1,36 @@
+export declare class Event {
+    target: any;
+    type: string;
+    constructor(type: string, target: any);
+}
+export declare class ErrorEvent extends Event {
+    message: string;
+    error: Error;
+    constructor(error: Error, target: any);
+}
+export declare class CloseEvent extends Event {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+    constructor(code: number | undefined, reason: string | undefined, target: any);
+}
+export interface WebSocketEventMap {
+    close: CloseEvent;
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+}
+export interface WebSocketEventListenerMap {
+    close: (event: CloseEvent) => void | {
+        handleEvent: (event: CloseEvent) => void;
+    };
+    error: (event: ErrorEvent) => void | {
+        handleEvent: (event: ErrorEvent) => void;
+    };
+    message: (event: MessageEvent) => void | {
+        handleEvent: (event: MessageEvent) => void;
+    };
+    open: (event: Event) => void | {
+        handleEvent: (event: Event) => void;
+    };
+}

package/core/websocket/events.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloseEvent = exports.ErrorEvent = exports.Event = void 0;
+class Event {
+    constructor(type, target) {
+        this.target = target;
+        this.type = type;
+    }
+}
+exports.Event = Event;
+class ErrorEvent extends Event {
+    constructor(error, target) {
+        super("error", target);
+        this.message = error.message;
+        this.error = error;
+    }
+}
+exports.ErrorEvent = ErrorEvent;
+class CloseEvent extends Event {
+    constructor(code = 1000, reason = "", target) {
+        super("close", target);
+        this.wasClean = true;
+        this.code = code;
+        this.reason = reason;
+    }
+}
+exports.CloseEvent = CloseEvent;

package/core/websocket/index.d.ts

@@ -0,0 +1 @@
+export * from "./ws";

package/core/websocket/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ws"), exports);

package/core/websocket/ws.d.ts

@@ -0,0 +1,137 @@
+import * as Events from "./events";
+export type Event = Events.Event;
+export type ErrorEvent = Events.ErrorEvent;
+export type CloseEvent = Events.CloseEvent;
+export type Options = {
+    WebSocket?: any;
+    maxReconnectionDelay?: number;
+    minReconnectionDelay?: number;
+    reconnectionDelayGrowFactor?: number;
+    minUptime?: number;
+    connectionTimeout?: number;
+    maxRetries?: number;
+    maxEnqueuedMessages?: number;
+    startClosed?: boolean;
+    debug?: boolean;
+};
+export type UrlProvider = string | (() => string) | (() => Promise<string>);
+export type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+export type ListenersMap = {
+    error: Array<Events.WebSocketEventListenerMap["error"]>;
+    message: Array<Events.WebSocketEventListenerMap["message"]>;
+    open: Array<Events.WebSocketEventListenerMap["open"]>;
+    close: Array<Events.WebSocketEventListenerMap["close"]>;
+};
+export declare class ReconnectingWebSocket {
+    private _ws?;
+    private _listeners;
+    private _retryCount;
+    private _uptimeTimeout;
+    private _connectTimeout;
+    private _shouldReconnect;
+    private _connectLock;
+    private _binaryType;
+    private _closeCalled;
+    private _messageQueue;
+    private readonly _url;
+    private readonly _protocols?;
+    private readonly _options;
+    private readonly _headers?;
+    constructor(url: UrlProvider, protocols?: string | string[], options?: Options, headers?: Record<string, any>);
+    static get CONNECTING(): number;
+    static get OPEN(): number;
+    static get CLOSING(): number;
+    static get CLOSED(): number;
+    get CONNECTING(): number;
+    get OPEN(): number;
+    get CLOSING(): number;
+    get CLOSED(): number;
+    get binaryType(): BinaryType;
+    set binaryType(value: BinaryType);
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount(): number;
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount(): number;
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions(): string;
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol(): string;
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState(): number;
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url(): string;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+     */
+    onclose: ((event: Events.CloseEvent) => void) | null;
+    /**
+     * An event listener to be called when an error occurs
+     */
+    onerror: ((event: Events.ErrorEvent) => void) | null;
+    /**
+     * An event listener to be called when a message is received from the server
+     */
+    onmessage: ((event: MessageEvent) => void) | null;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data
+     */
+    onopen: ((event: Event) => void) | null;
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code?: number, reason?: string): void;
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data: Message): void;
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    private _debug;
+    private _getNextDelay;
+    private _wait;
+    private _getNextUrl;
+    private _connect;
+    private _handleTimeout;
+    private _disconnect;
+    private _acceptOpen;
+    private _callEventListener;
+    private _handleOpen;
+    private _handleMessage;
+    private _handleError;
+    private _handleClose;
+    private _removeListeners;
+    private _addListeners;
+    private _clearTimeouts;
+}