@adapt-arch/utiliti-es 0.1.0

package/dist/logger/reporters/xhrReporter.js

@@ -0,0 +1,108 @@
+/**
+ * HTTP Reporter options.
+ */
+export class XhrReporterOptions {
+    /**
+     * Endpoint that receives the logs.
+     */
+    endpoint = "";
+    /**
+     * HTTP verb used when calling the endpoint.
+     */
+    verb = "POST";
+    /**
+     * The number of items to send in a batch.
+     */
+    batchSize = 20;
+    /**
+     * The maximum interval, in milliseconds, to wait for the batch size to be achieved before reporting.
+     */
+    interval = 2_000;
+    /**
+     * A function that can be used to transform the request before sending it.
+     */
+    requestTransform;
+}
+export class XhrReporter {
+    _messageQueue;
+    _options;
+    _reportActionTimeoutRef;
+    _reportActionPromise;
+    _disposed;
+    constructor(options) {
+        if (!options) {
+            throw new Error('Argument "options" is required');
+        }
+        this._messageQueue = [];
+        this._options = options;
+        this._reportActionTimeoutRef = undefined;
+        this._reportActionPromise = null;
+        this._disposed = false;
+    }
+    /**
+     * @inheritdoc
+     */
+    register(message) {
+        if (this._disposed) {
+            return;
+        }
+        this._messageQueue.push(message);
+        this._scheduleNextProcessAction();
+    }
+    /**
+     * @inheritdoc
+     */
+    async [Symbol.asyncDispose]() {
+        if (this._disposed) {
+            return Promise.resolve();
+        }
+        await (this._reportActionPromise ?? this._processMessages());
+        this._disposed = true;
+    }
+    _scheduleNextProcessAction() {
+        if (this._reportActionTimeoutRef) {
+            return; // Already scheduled
+        }
+        const interval = this._messageQueue.length >= this._options.batchSize ? 0 : this._options.interval;
+        this._reportActionTimeoutRef = setTimeout(() => {
+            this._reportActionPromise = this._processMessages().then(() => {
+                const prevRef = this._reportActionTimeoutRef;
+                this._reportActionTimeoutRef = undefined;
+                clearTimeout(prevRef);
+                this._reportActionPromise = null;
+                this._scheduleNextProcessAction();
+            });
+        }, interval);
+    }
+    async _processMessages() {
+        let messages;
+        let success;
+        while (this._messageQueue.length > 0) {
+            messages = this._messageQueue.splice(0, Math.min(this._messageQueue.length, this._options.batchSize));
+            success = await this._sendMessagesBatch(messages);
+            if (!success) {
+                this._messageQueue.unshift(...messages);
+                return;
+            }
+        }
+    }
+    _sendMessagesBatch(messages) {
+        return new Promise((resolve) => {
+            const failureHandler = () => {
+                resolve(false);
+            };
+            const request = new XMLHttpRequest();
+            request.open(this._options.verb, this._options.endpoint);
+            request.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
+            if (this._options.requestTransform) {
+                this._options.requestTransform(request);
+            }
+            request.onload = function () {
+                resolve(this.status >= 200 && this.status < 300);
+            };
+            request.onerror = failureHandler;
+            request.onabort = failureHandler;
+            request.send(JSON.stringify(messages));
+        });
+    }
+}

package/dist/mocks/logReporterHandlers.d.ts

@@ -0,0 +1 @@
+export declare function getLogReporterHandlers(handledRequestsContainer?: Array<Request>): import("msw").HttpHandler[];

package/dist/mocks/logReporterHandlers.js

@@ -0,0 +1,27 @@
+import { http, HttpResponse, delay } from "msw";
+// https://mswjs.io/docs/basics/mocking-responses
+export function getLogReporterHandlers(handledRequestsContainer) {
+    return [
+        http.post("/logs*", async ({ request }) => {
+            if (handledRequestsContainer) {
+                handledRequestsContainer.push(request.clone());
+            }
+            // Get the responseCode from the query string
+            const responseCode = new URL(request.url).searchParams.get("responseCode");
+            let status = responseCode ? Number.parseInt(responseCode) : 200;
+            if (Number.isNaN(status)) {
+                status = 200;
+            }
+            if (status < 200 || status < 300) {
+                await delay(60); // Simulate network latency
+            }
+            if (status === 0) {
+                // Simulate a network error
+                return HttpResponse.error();
+            }
+            return new HttpResponse(null, {
+                status: status,
+            });
+        }),
+    ];
+}

package/dist/pubsub/contracts.d.ts

@@ -0,0 +1,39 @@
+import type { SerializableValues } from "../common";
+/**
+ * The types of message values that can be published.
+ */
+export type MessageValue = SerializableValues;
+/**
+ * The type of a message.
+ */
+export type MessageData = Record<string, MessageValue>;
+/**
+ * A simple message handler.
+ */
+export type MessageHandler = (topic: string, message: MessageData) => void;
+/**
+ * A simple pub/sub component.
+ */
+export interface IPubSubHub {
+    /**
+     * Publish a message to a topic.
+     *
+     * @param {string} topic The topic to publish to.
+     * @param {MessageData} message The message to publish.
+     **/
+    publish(topic: string, message: MessageData): void;
+    /**
+     * Subscribe to a topic.
+     *
+     * @param {string} topic  The topic to subscribe to.
+     * @param {MessageHandler} handler The handler to call when a message is published.
+     * @returns {string} The id of the handler subscription if the subscription is successful.
+     **/
+    subscribe(topic: string, handler: MessageHandler): string | null;
+    /**
+     * Unsubscribe from a topic.
+     *
+     * @param {string} subscriptionId The subscription id to unsubscribe.
+     **/
+    unsubscribe(subscriptionId: string): void;
+}

package/dist/pubsub/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/pubsub/index.d.ts

@@ -0,0 +1,2 @@
+export type { IPubSubHub, MessageHandler, MessageData, MessageValue } from "./contracts";
+export { PubSubHub } from "./pubsub";

package/dist/pubsub/index.js

@@ -0,0 +1 @@
+export { PubSubHub } from "./pubsub";

package/dist/pubsub/pubsub.d.ts

@@ -0,0 +1,13 @@
+import type { IPubSubHub, MessageData, MessageHandler } from "./contracts";
+/**
+ * A PubSub implementation.
+ */
+export declare class PubSubHub implements IPubSubHub {
+    private _subscriptions;
+    /** @inheritdoc */
+    publish(topic: string, message: MessageData): void;
+    /** @inheritdoc */
+    subscribe(topic: string, handler: MessageHandler): string | null;
+    /** @inheritdoc */
+    unsubscribe(subscriptionId: string): void;
+}

package/dist/pubsub/pubsub.js

@@ -0,0 +1,51 @@
+/**
+ * A PubSub implementation.
+ */
+export class PubSubHub {
+    _subscriptions = new Map();
+    /** @inheritdoc */
+    publish(topic, message) {
+        if (!topic) {
+            throw new Error("Invalid topic.");
+        }
+        if (!message) {
+            throw new Error("Invalid message.");
+        }
+        const handlers = this._subscriptions.get(topic);
+        if (handlers) {
+            for (const handler of handlers.values()) {
+                const newTopic = structuredClone(topic);
+                const newMessage = structuredClone(message);
+                setTimeout(() => handler(newTopic, newMessage), 0);
+            }
+        }
+    }
+    /** @inheritdoc */
+    subscribe(topic, handler) {
+        if (!topic) {
+            throw new Error("Invalid topic.");
+        }
+        if (!handler) {
+            throw new Error("Invalid handler.");
+        }
+        let handlers = this._subscriptions.get(topic);
+        if (!handlers) {
+            handlers = new Map();
+            this._subscriptions.set(structuredClone(topic), handlers);
+        }
+        const subscriptionId = `sub-${Date.now()}`;
+        handlers.set(subscriptionId, handler);
+        return subscriptionId;
+    }
+    /** @inheritdoc */
+    unsubscribe(subscriptionId) {
+        if (!subscriptionId) {
+            return;
+        }
+        for (const handlers of this._subscriptions.values()) {
+            if (handlers.delete(subscriptionId)) {
+                return;
+            }
+        }
+    }
+}

package/dist/utils/delay.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get a promise that resolves after a certain duration.
+ *
+ * @param {number} duration The duration to wait before resolving the promise.
+ * @param {Error?} error An optional error to throw instead of resolving the promise.
+ * @returns {Promise<void>} A promise that resolves after a certain duration.
+ */
+export declare function delay(duration?: number, error?: Error): Promise<void>;

package/dist/utils/delay.js

@@ -0,0 +1,14 @@
+/**
+ * Get a promise that resolves after a certain duration.
+ *
+ * @param {number} duration The duration to wait before resolving the promise.
+ * @param {Error?} error An optional error to throw instead of resolving the promise.
+ * @returns {Promise<void>} A promise that resolves after a certain duration.
+ */
+export function delay(duration = 1, error) {
+    return new Promise((res, rej) => {
+        setTimeout(() => {
+            error ? rej(error) : res();
+        }, duration);
+    });
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export { delay } from "./delay";

package/dist/utils/index.js

@@ -0,0 +1 @@
+export { delay } from "./delay";

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@adapt-arch/utiliti-es",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "EcmaScript library with common utilities",
+  "keywords": [
+    "adaptive",
+    "architecture",
+    "pubsub",
+    "logger",
+    "utilities",
+    "common"
+  ],
+  "type": "module",
+  "files": [
+    "dist/**",
+    "LICENSE",
+    "README.md"
+  ],
+  "main": "dist/utiliti-es.umd.cjs",
+  "module": "dist/utiliti-es.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/bundle/utiliti-es.js",
+      "require": "./dist/bundle/utiliti-es.cjs",
+      "node": {
+        "import": {
+          "production": "./dist/bundle/utiliti-es.js",
+          "development": "./dist/index.js",
+          "default": "./dist/index.js"
+        }
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adaptive-architecture/utiliti-es"
+  },
+  "bugs": {
+    "url": "https://github.com/adaptive-architecture/utiliti-es/issues"
+  },
+  "author": {
+    "name": "Adaptive Architecture"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "dev": "vite",
+    "empty-output": "node ./ci-cd/empty-output.js",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "lint": "npx @biomejs/biome check --apply ./",
+    "test": "vitest run --coverage",
+    "docs": "typedoc"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.7.0",
+    "@types/node": "20.12.7",
+    "@vitest/coverage-v8": "1.5.0",
+    "jsdom": "24.0.0",
+    "msw": "2.2.14",
+    "typedoc": "0.25.13",
+    "typescript": "5.4.5",
+    "vite": "5.2.9",
+    "vitest": "1.5.0"
+  },
+  "msw": {
+    "workerDirectory": [
+      "public"
+    ]
+  }
+}