@synnaxlabs/x 0.7.0

package/src/toArray.ts

@@ -0,0 +1,11 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export const toArray = <T>(value: T | T[]): T[] =>
+  Array.isArray(value) ? value : [value];

package/src/transform.ts

@@ -0,0 +1,10 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export type ArrayTransform<E = unknown, R = E> = (data: E[]) => R[];

package/src/unique.ts

@@ -0,0 +1,10 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export const unique = <V>(values: V[] | readonly V[]): V[] => [...new Set(values)];

package/src/url/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * from "./url";

package/src/url/url.spec.ts

@@ -0,0 +1,47 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, test } from "vitest";
+
+import { URL } from "@/url";
+
+describe("URL", () => {
+  test("URL - child", () => {
+    const endpoint = new URL({
+      host: "localhost",
+      port: 8080,
+      protocol: "http",
+      pathPrefix: "api",
+    });
+    expect(endpoint.child("test").toString()).toEqual("http://localhost:8080/api/test");
+  });
+
+  test("URL - child with trailing slash", () => {
+    const endpoint = new URL({
+      host: "localhost",
+      port: 8080,
+      protocol: "http",
+      pathPrefix: "api",
+    });
+    const child = endpoint.child("test/");
+    expect(child.toString()).toEqual("http://localhost:8080/api/test");
+  });
+
+  test("URL - replacing protocol", () => {
+    const endpoint = new URL({
+      host: "localhost",
+      port: 8080,
+      protocol: "http",
+      pathPrefix: "api",
+    });
+    expect(endpoint.child("test").replace({ protocol: "https" }).toString()).toEqual(
+      "https://localhost:8080/api/test"
+    );
+  });
+});

package/src/url/url.ts

@@ -0,0 +1,113 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+interface URLProps {
+  host: string;
+  port: number;
+  protocol?: string;
+  pathPrefix?: string;
+  params?: string;
+}
+
+/** @returns the paths joined with a single slash */
+const joinPaths = (...paths: string[]): string => paths.map(formatPath).join("");
+
+/** ensures that a path is correctly formatted for joining */
+const formatPath = (path: string): string => {
+  if (!path.endsWith("/")) path += "/";
+  if (path.startsWith("/")) path = path.slice(1);
+  return path;
+};
+
+/** removes the trailing slash from a path */
+const removeTrailingSlash = (path: string): string =>
+  path.endsWith("/") ? path.slice(0, -1) : path;
+
+/**
+ * Builds a query string from a record.
+ * @param record - The record to build the query string from. If the record is null,
+ * an empty string is returned.
+ * @returns the query string.
+ */
+export const buildQueryString = (
+  request: Record<string, unknown>,
+  prefix: string = ""
+): string => {
+  if (request === null) return "";
+  return (
+    "?" +
+    Object.entries(request)
+      .filter(([, value]) => {
+        if (value === undefined || value === null) return false;
+        if (Array.isArray(value)) return value.length > 0;
+        return true;
+      })
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      .map(([key, value]) => `${prefix}${key}=${value}`)
+      .join("&")
+  );
+};
+
+/**
+ * URL is a simple class for building and extending URLs.
+ */
+export class URL {
+  protocol: string;
+  host: string;
+  port: number;
+  path: string;
+
+  /**
+   * @param host - The hostname or IP address of the server.
+   * @param port - The port number of the server.
+   * @param protocol - The protocol to use for all requests. Defaults to "".
+   * @param pathPrefix - A path prefix to use for all requests. Defaults to "".
+   */
+  constructor({ host, port, protocol = "", pathPrefix = "" }: URLProps) {
+    this.protocol = protocol;
+    this.host = host;
+    this.port = port;
+    this.path = formatPath(pathPrefix);
+  }
+
+  /**
+   * Replaces creates a new URL with the specified properties replaced.
+   * @param props - The properties to replace.
+   * @returns a new URL.
+   */
+  replace(props: Partial<URLProps>): URL {
+    return new URL({
+      host: props.host ?? this.host,
+      port: props.port ?? this.port,
+      protocol: props.protocol ?? this.protocol,
+      pathPrefix: props.pathPrefix ?? this.path,
+    });
+  }
+
+  /**
+   * Creates a new url with the given path appended to the current path.
+   * @param path - the path to append to the URL.
+   * @returns a new URL.
+   */
+  child(path: string): URL {
+    return new URL({
+      ...this,
+      pathPrefix: joinPaths(this.path, path),
+    });
+  }
+
+  /** @returns a string representation of the url */
+  toString(): string {
+    return removeTrailingSlash(
+      `${this.protocol}://${this.host}:${this.port}/${this.path}`
+    );
+  }
+
+  static readonly UNKNOWN = new URL({ host: "unknown", port: 0 });
+}

package/src/worker/worker.spec.ts

@@ -0,0 +1,41 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, it, vi } from "vitest";
+
+import { createMockWorkers } from "./worker";
+
+interface MockMessage {
+  value: string;
+}
+
+describe("Worker", () => {
+  it("should correctly send and handle a message from a typed worker", () => {
+    const [a, b] = createMockWorkers();
+    const aT = a.route<MockMessage>("dog");
+    const bT = b.route<MockMessage>("dog");
+    const handler = vi.fn();
+    bT.handle(handler);
+    aT.send({ value: "hello" });
+    expect(handler).toHaveBeenCalledWith({ value: "hello" });
+  });
+  it("should route the message to the correct location", () => {
+    const [a, b] = createMockWorkers();
+    const aT = a.route<MockMessage>("dog");
+    const bT = b.route<MockMessage>("cat");
+    const dogBT = b.route<MockMessage>("dog");
+    const handler = vi.fn();
+    bT.handle(handler);
+    const dogHandler = vi.fn();
+    dogBT.handle(dogHandler);
+    aT.send({ value: "hello" });
+    expect(handler).not.toHaveBeenCalled();
+    expect(dogHandler).toHaveBeenCalled();
+  });
+});

package/src/worker/worker.ts

@@ -0,0 +1,86 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export interface Sender<T> {
+  send: (value: T, transfer?: Transferable[]) => void;
+}
+
+export interface Handler<T> {
+  handle: (handler: (value: T) => void) => void;
+}
+
+export interface SenderHandler<I, O> extends Sender<I>, Handler<O> {}
+
+interface TypedWorkerMessage {
+  type: string;
+  payload: any;
+}
+
+type SendFunc = (value: any, transfer?: Transferable[]) => void;
+type HandlerFunc = (value: any) => void;
+
+export class RoutedWorker {
+  sender: SendFunc;
+  handlers: Map<string, TypedWorker<any>>;
+
+  constructor(send: SendFunc) {
+    this.sender = send;
+    this.handlers = new Map();
+  }
+
+  handle({ data }: { data: TypedWorkerMessage }): void {
+    const handler = this.handlers.get(data.type)?.handler;
+    if (handler == null) console.warn(`No handler for ${data.type}`);
+    else handler(data.payload);
+  }
+
+  route<RQ, RS = RQ>(type: string): TypedWorker<RQ, RS> {
+    const send = typedSend(type, this.sender);
+    const t = new TypedWorker<RQ, RS>(send);
+    this.handlers.set(type, t);
+    return t;
+  }
+}
+
+const typedSend =
+  (type: string, send: SendFunc): SendFunc =>
+  (payload: any, transfer?: Transferable[]) => {
+    return send({ type, payload }, transfer);
+  };
+
+export class TypedWorker<RQ, RS = RQ> implements SenderHandler<RQ, RS> {
+  private readonly _send: SendFunc;
+  handler: HandlerFunc | null;
+
+  constructor(send: SendFunc) {
+    this._send = send;
+    this.handler = null;
+  }
+
+  send(payload: RQ, transfer: Transferable[] = []): void {
+    this._send(payload, transfer);
+  }
+
+  handle(handler: (payload: RS) => void): void {
+    this.handler = handler;
+  }
+}
+
+export const createMockWorkers = (): [RoutedWorker, RoutedWorker] => {
+  let a: RoutedWorker, b: RoutedWorker;
+  const aSend = (value: any, transfer?: Transferable[]): void => {
+    b.handle({ data: value });
+  };
+  const bSend = (value: any, transfer?: Transferable[]): void => {
+    a.handle({ data: value });
+  };
+  a = new RoutedWorker(aSend);
+  b = new RoutedWorker(bSend);
+  return [a, b];
+};

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@synnaxlabs/tsconfig/base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.vite.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@synnaxlabs/tsconfig/vite.json",
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,23 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { lib } from "@synnaxlabs/vite-plugin";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [lib({ name: "x" })],
+  build: {
+    sourcemap: true,
+    minify: false,
+  },
+  test: {
+    globals: true,
+    environment: "jsdom",
+  },
+});