@synnaxlabs/x 0.16.1 → 0.24.0

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "private": false,
-  "version": "0.16.1",
+  "version": "0.24.0",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",
@@ -14,25 +13,170 @@
     "control systems"
   ],
   "dependencies": {
-    "async-mutex": "^0.4.1",
     "js-convert-case": "^4.2.0",
-    "nanoid": "^3.3.7",
-    "typescript": "^5.4.5",
-    "zod": "3.22.4"
+    "nanoid": "^3.0.0",
+    "zod": "3.23.8"
   },
   "devDependencies": {
     "@types/node": "^20.12.7",
-    "@vitest/coverage-v8": "1.2.2",
-    "eslint": "^8.57.0",
-    "vite": "5.1.2",
-    "vitest": "1.2.2",
+    "@vitest/coverage-v8": "^1.5.0",
+    "vitest": "^1.5.0",
+    "vite": "5.2.11",
+    "typescript": "^5.4.5",
     "@synnaxlabs/tsconfig": "0.0.2",
     "@synnaxlabs/vite-plugin": "0.0.1",
     "eslint-config-synnaxlabs": "0.0.1"
   },
-  "main": "dist/x.cjs",
-  "module": "dist/x.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/src/index.d.ts"
+    },
+    "./binary": {
+      "import": "./dist/binary.js",
+      "require": "./dist/binary.cjs",
+      "types": "./dist/src/binary/index.d.ts"
+    },
+    "./compare": {
+      "import": "./dist/compare.js",
+      "require": "./dist/compare.cjs",
+      "types": "./dist/src/compare/index.d.ts"
+    },
+    "./deep": {
+      "import": "./dist/deep.js",
+      "require": "./dist/deep.cjs",
+      "types": "./dist/src/deep/index.d.ts"
+    },
+    "./kv": {
+      "import": "./dist/kv.js",
+      "require": "./dist/kv.cjs",
+      "types": "./dist/src/kv/index.d.ts"
+    },
+    "./runtime": {
+      "import": "./dist/runtime.js",
+      "require": "./dist/runtime.cjs",
+      "types": "./dist/src/runtime/index.d.ts"
+    },
+    "./observe": {
+      "import": "./dist/observe.js",
+      "require": "./dist/observe.cjs",
+      "types": "./dist/src/observe/index.d.ts"
+    },
+    "./box": {
+      "import": "./dist/box.js",
+      "require": "./dist/box.cjs",
+      "types": "./dist/src/spatial/box/index.d.ts"
+    },
+    "./bounds": {
+      "import": "./dist/bounds.js",
+      "require": "./dist/bounds.cjs",
+      "types": "./dist/src/spatial/bounds/index.d.ts"
+    },
+    "./dimensions": {
+      "import": "./dist/dimensions.js",
+      "require": "./dist/dimensions.cjs",
+      "types": "./dist/src/spatial/dimensions/index.d.ts"
+    },
+    "./direction": {
+      "import": "./dist/direction.js",
+      "require": "./dist/direction.cjs",
+      "types": "./dist/src/spatial/direction/index.d.ts"
+    },
+    "./location": {
+      "import": "./dist/location.js",
+      "require": "./dist/location.cjs",
+      "types": "./dist/src/spatial/location/index.d.ts"
+    },
+    "./position": {
+      "import": "./dist/position.js",
+      "require": "./dist/position.cjs",
+      "types": "./dist/src/spatial/position/index.d.ts"
+    },
+    "./scale": {
+      "import": "./dist/scale.js",
+      "require": "./dist/scale.cjs",
+      "types": "./dist/src/spatial/scale/index.d.ts"
+    },
+    "./xy": {
+      "import": "./dist/xy.js",
+      "require": "./dist/xy.cjs",
+      "types": "./dist/src/spatial/xy/index.d.ts"
+    },
+    "./spatial": {
+      "import": "./dist/spatial.js",
+      "require": "./dist/spatial.cjs",
+      "types": "./dist/src/spatial/index.d.ts"
+    },
+    "./telem": {
+      "import": "./dist/telem.js",
+      "require": "./dist/telem.cjs",
+      "types": "./dist/src/telem/index.d.ts"
+    },
+    "./url": {
+      "import": "./dist/url.js",
+      "require": "./dist/url.cjs",
+      "types": "./dist/src/url/index.d.ts"
+    },
+    "./worker": {
+      "import": "./dist/worker.js",
+      "require": "./dist/worker.cjs",
+      "types": "./dist/src/worker/index.d.ts"
+    },
+    "./destructor": {
+      "import": "./dist/destructor.js",
+      "require": "./dist/destructor.cjs",
+      "types": "./dist/src/destructor.d.ts"
+    },
+    "./debounce": {
+      "import": "./dist/debounce.js",
+      "require": "./dist/debounce.cjs",
+      "types": "./dist/src/debounce/index.d.ts"
+    },
+    "./toArray": {
+      "import": "./dist/toArray.js",
+      "require": "./dist/toArray.cjs",
+      "types": "./dist/src/toArray.d.ts"
+    },
+    "./search": {
+      "import": "./dist/search.js",
+      "require": "./dist/search.cjs",
+      "types": "./dist/src/search.d.ts"
+    },
+    "./unique": {
+      "import": "./dist/unique.js",
+      "require": "./dist/unique.cjs",
+      "types": "./dist/src/unique.d.ts"
+    },
+    "./record": {
+      "import": "./dist/record.js",
+      "require": "./dist/record.cjs",
+      "types": "./dist/src/record.d.ts"
+    },
+    "./change": {
+      "import": "./dist/change.js",
+      "require": "./dist/change.cjs",
+      "types": "./dist/src/change/index.d.ts"
+    },
+    "./identity": {
+      "import": "./dist/identity.js",
+      "require": "./dist/identity.cjs",
+      "types": "./dist/src/identity.d.ts"
+    },
+    "./caseconv": {
+      "import": "./dist/caseconv.js",
+      "require": "./dist/caseconv.cjs",
+      "types": "./dist/src/caseconv/index.d.ts"
+    },
+    "./zodutil": {
+      "import": "./dist/zodutil.js",
+      "require": "./dist/zodutil.cjs",
+      "types": "./dist/src/zodutil/index.d.ts"
+    }
+  },
   "scripts": {
     "build": "tsc --noEmit && vite build",
     "test": "vitest",

package/src/binary/encoder.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,25 +7,168 @@
 // 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 { describe, expect, it } from "vitest";
 import { z } from "zod";
 
 import { binary } from "@/binary";
 
-const SampleSchema = z.object({
+const sampleSchema = z.object({
   channelKey: z.string(),
   timeStamp: z.number(),
   value: z.unknown(),
 });
 
-describe.each(binary.ENCODERS)("encoder", (e) => {
-  test(`[encoder] - encoder ${e.contentType} should encode correctly`, () => {
+binary.ENCODERS.forEach((e) => {
+  describe(`encoder ${e.contentType}`, () => {
+    it("should correctly encode and decode items", () => {
+      const sample = {
+        channelKey: "test",
+        timeStamp: 123,
+        value: new Array([1, 2, 3]),
+      };
+      const encoded = e.encode(sample);
+      expect(e.decode(encoded, sampleSchema)).toEqual(sample);
+    });
+  });
+});
+
+describe("JSON", () => {
+  it("should correctly convert keys to snake case", () => {
     const sample = {
       channelKey: "test",
       timeStamp: 123,
       value: new Array([1, 2, 3]),
     };
-    const encoded = e.encode(sample);
-    expect(e.decode(encoded, SampleSchema)).toEqual(sample);
+    const encoded = binary.JSON_ECD.encodeString(sample);
+    const parse = JSON.parse(encoded);
+    expect(parse.channel_key).toEqual("test");
+  });
+  it("should correctly decode keys from snake case", () => {
+    const sample = {
+      channel_key: "test",
+      time_stamp: 123,
+      value: new Array([1, 2, 3]),
+    };
+    const encoded = JSON.stringify(sample);
+    const decoded = binary.JSON_ECD.decodeString(encoded, sampleSchema);
+    expect(decoded.channelKey).toEqual("test");
+  });
+
+  describe("CSVEncoderDecoder", () => {
+    it("should correctly decode CSV data with valid input", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,5
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [5, 6],
+      });
+    });
+
+    it("should handle empty CSV data", () => {
+      const sample = `
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({});
+    });
+
+    it("should handle CSV with only headers", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: [],
+        timeStamp: [],
+        value: [],
+      });
+    });
+
+    it("should handle CSV with missing values", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [6],
+      });
+    });
+
+    it("should handle CSV with extra values", () => {
+      const sample = `
+      channelKey,timeStamp,value
+      test,123,5,extra
+      test2,124,6
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        channelKey: ["test", "test2"],
+        timeStamp: [123, 124],
+        value: [5, 6],
+      });
+    });
+
+    it("should handle CSV with different types of values", () => {
+      const sample = `
+      key,number,string
+      test,123,"hello"
+      test2,456,"world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with spaces around values", () => {
+      const sample = `
+      key, number , string
+      test , 123 , "hello"
+      test2 , 456 , "world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with empty rows", () => {
+      const sample = `
+      key,number,string
+      test,123,"hello"
+      ,
+      test2,456,"world"
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+        number: [123, 456],
+        string: ["hello", "world"],
+      });
+    });
+
+    it("should handle CSV with single column", () => {
+      const sample = `
+      key
+      test
+      test2
+      `;
+      const decoded = binary.CSV_ECD.decodeString(sample);
+      expect(decoded).toEqual({
+        key: ["test", "test2"],
+      });
+    });
   });
 });

package/src/binary/encoder.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,9 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type ZodSchema, type z } from "zod";
+import { type z, type ZodSchema } from "zod";
 
-import { Case } from "@/case";
+import { caseconv } from "@/caseconv";
 import { isObject } from "@/identity";
 
 /**
@@ -40,14 +40,32 @@ export interface EncoderDecoder {
 /** JSONEncoderDecoder is a JSON implementation of EncoderDecoder. */
 export class JSONEncoderDecoder implements EncoderDecoder {
   contentType = "application/json";
-  readonly decoder: TextDecoder;
+  private readonly decoder: TextDecoder;
+  private readonly encoder: TextEncoder;
 
   constructor() {
     this.decoder = new TextDecoder();
+    this.encoder = new TextEncoder();
   }
 
   encode(payload: unknown): ArrayBuffer {
-    const json = JSON.stringify(Case.toSnake(payload), (_, v) => {
+    return this.encoder.encode(this.encodeString(payload)).buffer;
+  }
+
+  decode<P extends z.ZodTypeAny>(
+    data: Uint8Array | ArrayBuffer,
+    schema?: P,
+  ): z.output<P> {
+    return this.decodeString(this.decoder.decode(data), schema);
+  }
+
+  decodeString<P extends z.ZodTypeAny>(data: string, schema?: P): z.output<P> {
+    const unpacked = caseconv.toCamel(JSON.parse(data));
+    return schema != null ? schema.parse(unpacked) : (unpacked as z.output<P>);
+  }
+
+  encodeString(payload: unknown): string {
+    return JSON.stringify(caseconv.toSnake(payload), (_, v) => {
       if (ArrayBuffer.isView(v)) return Array.from(v as Uint8Array);
       if (isObject(v) && "encode_value" in v) {
         if (typeof v.value === "bigint") return v.value.toString();
@@ -56,18 +74,101 @@ export class JSONEncoderDecoder implements EncoderDecoder {
       if (typeof v === "bigint") return v.toString();
       return v;
     });
-    return new TextEncoder().encode(json);
+  }
+
+  static registerCustomType(): void {}
+}
+
+/**
+ * CSVEncoderDecoder is a CSV implementation of EncoderDecoder.
+ */
+export class CSVEncoderDecoder implements EncoderDecoder {
+  contentType = "text/csv";
+
+  encode(payload: unknown): ArrayBuffer {
+    const csvString = this.encodeString(payload);
+    return new TextEncoder().encode(csvString).buffer;
   }
 
   decode<P extends z.ZodTypeAny>(
     data: Uint8Array | ArrayBuffer,
     schema?: P,
   ): z.output<P> {
-    const unpacked = Case.toCamel(JSON.parse(this.decoder.decode(data)));
-    return schema != null ? schema.parse(unpacked) : (unpacked as P);
+    const csvString = new TextDecoder().decode(data);
+    return this.decodeString(csvString, schema);
+  }
+
+  encodeString(payload: unknown): string {
+    if (!Array.isArray(payload) || payload.length === 0 || !isObject(payload[0])) {
+      throw new Error("Payload must be an array of objects");
+    }
+
+    const keys = Object.keys(payload[0]);
+    const csvRows = [keys.join(",")];
+
+    payload.forEach((item: any) => {
+      const values = keys.map((key) => JSON.stringify(item[key] ?? ""));
+      csvRows.push(values.join(","));
+    });
+
+    return csvRows.join("\n");
+  }
+
+  decodeString<P extends z.ZodTypeAny>(data: string, schema?: P): z.output<P> {
+    const [headerLine, ...lines] = data
+      .trim()
+      .split("\n")
+      .map((line) => line.trim());
+    if (headerLine.length === 0)
+      return schema != null ? schema.parse({}) : ({} as z.output<P>);
+    const headers = headerLine.split(",").map((header) => header.trim());
+    const result: { [key: string]: any[] } = {};
+
+    headers.forEach((header) => {
+      result[header] = [];
+    });
+
+    lines.forEach((line) => {
+      const values = line.split(",").map((value) => value.trim());
+      headers.forEach((header, index) => {
+        const v = this.parseValue(values[index]);
+        if (v == null) return;
+        result[header].push(v);
+      });
+    });
+
+    return schema != null ? schema.parse(result) : (result as z.output<P>);
+  }
+
+  private parseValue(value?: string): any {
+    if (value == null || value.length === 0) return null;
+    const num = Number(value);
+    if (!isNaN(num)) return num;
+    if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+    return value;
   }
 
   static registerCustomType(): void {}
 }
 
-export const ENCODERS: EncoderDecoder[] = [new JSONEncoderDecoder()];
+export class TextEncoderDecoder implements EncoderDecoder {
+  contentType = "text/plain";
+
+  encode(payload: unknown): ArrayBuffer {
+    return new TextEncoder().encode(payload as string).buffer;
+  }
+
+  decode<P extends z.ZodTypeAny>(
+    data: Uint8Array | ArrayBuffer,
+    schema?: P,
+  ): z.output<P> {
+    const text = new TextDecoder().decode(data);
+    return schema != null ? schema.parse(text) : (text as z.output<P>);
+  }
+}
+
+export const JSON_ECD = new JSONEncoderDecoder();
+export const CSV_ECD = new CSVEncoderDecoder();
+export const TEXT_ECD = new TextEncoderDecoder();
+
+export const ENCODERS: EncoderDecoder[] = [JSON_ECD];

package/src/binary/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/caseconv/caseconv.ts

@@ -0,0 +1,31 @@
+// Copyright 2024 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 {
+  camelKeys as _camelKeys,
+  snakeKeys as _snakeKeys,
+  toCamelCase as _toCamelCase,
+  toSnakeCase as _toSnakeCase,
+} from "js-convert-case";
+
+const options = {
+  recursive: true,
+  recursiveInArray: true,
+  keepTypesOnRecursion: [Number, String, Uint8Array],
+};
+
+export const toSnake = <T>(entity: T): T => _snakeKeys(entity, options) as T;
+
+export const toCamel = <T>(entity: T): T => _camelKeys(entity, options) as T;
+
+export const capitalize = (str: string): string => str[0].toUpperCase() + str.slice(1);
+
+export const stringToSnake = (str: string): string => _toSnakeCase(str);
+
+export const stringToCamel = (str: string): string => _toCamelCase(str);

package/src/caseconv/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2024 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 * as caseconv from "@/caseconv/caseconv";

package/src/change/change.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -11,6 +11,7 @@ import { z } from "zod";
 
 export type Variant = "set" | "delete";
 
+ 
 export const Z = <V extends z.ZodTypeAny>(value: V) =>
   z.object({
     variant: z.enum(["set", "delete"]),
@@ -18,16 +19,16 @@ export const Z = <V extends z.ZodTypeAny>(value: V) =>
     value,
   });
 
-export type Set<K, V> = {
+export interface Set<K, V> {
   variant: "set";
   key: K;
   value: V;
-};
+}
 
-export type Delete<K, V> = {
+export interface Delete<K, V> {
   variant: "delete";
   key: K;
   value?: V;
-};
+}
 
-export type Change<K, V> = Set<K, V> | Delete<K, V>;
+export type Change<K, V> = Set<K, V> | Delete<K, V>;

package/src/change/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/{clamp.ts → clamp/clamp.ts}

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/clamp/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2024 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 * as clamp from "@/clamp/clamp";