@synnaxlabs/x 0.43.0 → 0.44.1

package/src/spatial/xy/xy.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import {
   type ClientXY,
@@ -293,3 +293,8 @@ export const swap = (a: Crude): XY => {
   const xy = construct(a);
   return { x: xy.y, y: xy.x };
 };
+
+export const round = (a: Crude): XY => {
+  const xy = construct(a);
+  return { x: Math.round(xy.x), y: Math.round(xy.y) };
+};

package/src/status/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as status from "@/status/types";
+export * as status from "@/status/status";

package/src/status/status.spec.ts

@@ -0,0 +1,25 @@
+// Copyright 2025 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 } from "vitest";
+
+import { id } from "@/id";
+import { status } from "@/status";
+import { TimeStamp } from "@/telem";
+
+describe("status", () => {
+  describe("create", () => {
+    it("should create a status", () => {
+      const s = status.create({ variant: "success", message: "test" });
+      expect(s.key).toHaveLength(id.LENGTH);
+      expect(s.time).toBeInstanceOf(TimeStamp);
+      expect(s.time.beforeEq(TimeStamp.now())).toBe(true);
+    });
+  });
+});

package/src/status/status.ts

@@ -0,0 +1,91 @@
+// Copyright 2025 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 { z } from "zod";
+
+import { id } from "@/id";
+import { type Optional } from "@/optional";
+import { TimeStamp } from "@/telem";
+
+export const variantZ = z.enum([
+  "success",
+  "info",
+  "warning",
+  "error",
+  "loading",
+  "disabled",
+]);
+
+// Represents one of the possible variants of a status message.
+export type Variant = z.infer<typeof variantZ>;
+
+type StatusZodObject<D extends z.ZodType> = z.ZodObject<{
+  key: z.ZodString;
+  variant: typeof variantZ;
+  message: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  time: typeof TimeStamp.z;
+  details: D;
+}>;
+
+interface StatusZFunction {
+  (): StatusZodObject<z.ZodOptional<z.ZodUnknown>>;
+  <D extends z.ZodType>(details: D): StatusZodObject<D>;
+}
+
+export const statusZ: StatusZFunction = <D extends z.ZodType>(details?: D) =>
+  z.object({
+    key: z.string(),
+    variant: variantZ,
+    message: z.string(),
+    description: z.string().optional(),
+    time: TimeStamp.z,
+    details: details ?? z.unknown().optional(),
+  });
+
+export type Status<D = undefined, V extends Variant = Variant> = {
+  key: string;
+  variant: V;
+  message: string;
+  description?: string;
+  time: TimeStamp;
+} & (D extends undefined ? {} : { details: D });
+
+export type Crude<D = undefined, V extends Variant = Variant> = Optional<
+  Status<D, V>,
+  "time" | "key"
+>;
+
+export interface ExceptionDetails {
+  stack: string;
+}
+
+export const fromException = (
+  exc: unknown,
+  message?: string,
+): Status<ExceptionDetails, "error"> => {
+  if (!(exc instanceof Error)) throw exc;
+  return create<ExceptionDetails, "error">({
+    variant: "error",
+    message: message ?? exc.message,
+    description: message != null ? exc.message : undefined,
+    details: {
+      stack: exc.stack ?? "",
+    },
+  });
+};
+
+export const create = <D = undefined, V extends Variant = Variant>(
+  spec: Crude<D, V>,
+): Status<D, V> =>
+  ({
+    key: id.create(),
+    time: TimeStamp.now(),
+    ...spec,
+  }) as unknown as Status<D, V>;

package/src/strings/strings.spec.ts

@@ -9,56 +9,94 @@
 
 import { describe, expect, it } from "vitest";
 
-import { createShortIdentifiers, naturalLanguageJoin } from "@/strings/strings";
+import { strings } from "@/strings";
 
 describe("naturalLanguageJoin", () => {
   it("should return an empty string for an empty array", () =>
-    expect(naturalLanguageJoin([])).toBe(""));
+    expect(strings.naturalLanguageJoin([])).toBe(""));
 
   it("should return the zeroLength string for an empty array if provided", () =>
-    expect(naturalLanguageJoin([], "No items")).toBe("No items"));
+    expect(strings.naturalLanguageJoin([], "No items")).toBe("No items"));
 
   it("should return the single element for an array with one element", () =>
-    expect(naturalLanguageJoin(["apple"])).toBe("apple"));
+    expect(strings.naturalLanguageJoin(["apple"])).toBe("apple"));
 
   it('should join two elements with "and"', () =>
-    expect(naturalLanguageJoin(["apple", "banana"])).toBe("apple and banana"));
+    expect(strings.naturalLanguageJoin(["apple", "banana"])).toBe("apple and banana"));
 
   it('should join multiple elements with commas and "and"', () =>
-    expect(naturalLanguageJoin(["apple", "banana", "cherry"])).toBe(
+    expect(strings.naturalLanguageJoin(["apple", "banana", "cherry"])).toBe(
       "apple, banana, and cherry",
     ));
 
   it("should handle an array with more than three elements correctly", () =>
-    expect(naturalLanguageJoin(["apple", "banana", "cherry", "date"])).toBe(
+    expect(strings.naturalLanguageJoin(["apple", "banana", "cherry", "date"])).toBe(
       "apple, banana, cherry, and date",
     ));
 });
 
 describe("createShortIdentifiers", () => {
   it("should create identifiers for a single word", () =>
-    expect(createShortIdentifiers("Bob")).toEqual(expect.arrayContaining(["bob"])));
+    expect(strings.createShortIdentifiers("Bob")).toEqual(
+      expect.arrayContaining(["bob"]),
+    ));
 
   it("should create identifiers for multiple words", () =>
-    expect(createShortIdentifiers("John Doe")).toEqual(
+    expect(strings.createShortIdentifiers("John Doe")).toEqual(
       expect.arrayContaining(["jd", "j_d", "johdoe", "joh_doe"]),
     ));
 
   it("should create identifiers for words containing numbers", () =>
-    expect(createShortIdentifiers("Alice 123")).toEqual(
+    expect(strings.createShortIdentifiers("Alice 123")).toEqual(
       expect.arrayContaining(["a1", "a_1", "ali123", "ali_123"]),
     ));
 
   it("should create identifiers for words longer than three characters", () =>
-    expect(createShortIdentifiers("Jonathan")).toEqual(
+    expect(strings.createShortIdentifiers("Jonathan")).toEqual(
       expect.arrayContaining(["jon"]),
     ));
 
   it("should create identifiers for words shorter than three characters", () =>
-    expect(createShortIdentifiers("Al")).toEqual(expect.arrayContaining(["al"])));
+    expect(strings.createShortIdentifiers("Al")).toEqual(
+      expect.arrayContaining(["al"]),
+    ));
 
   it("should create identifiers for mixed cases", () =>
-    expect(createShortIdentifiers("Alice Bob")).toEqual(
+    expect(strings.createShortIdentifiers("Alice Bob")).toEqual(
       expect.arrayContaining(["ab", "a_b", "alibob", "ali_bob"]),
     ));
 });
+
+describe("trimPrefix", () => {
+  it("should remove a prefix when it exists", () =>
+    expect(strings.trimPrefix("hello world", "hello ")).toBe("world"));
+
+  it("should return the original string when prefix does not exist", () =>
+    expect(strings.trimPrefix("hello world", "goodbye ")).toBe("hello world"));
+
+  it("should return the original string when prefix is empty", () =>
+    expect(strings.trimPrefix("hello world", "")).toBe("hello world"));
+
+  it("should return empty string when prefix equals the entire string", () =>
+    expect(strings.trimPrefix("hello world", "hello world")).toBe(""));
+
+  it("should handle case-sensitive matching", () =>
+    expect(strings.trimPrefix("Hello World", "hello ")).toBe("Hello World"));
+
+  it("should handle partial prefix matches", () =>
+    expect(strings.trimPrefix("hello world", "hello")).toBe(" world"));
+
+  it("should handle prefix longer than string", () =>
+    expect(strings.trimPrefix("hello", "hello world")).toBe("hello"));
+
+  it("should handle special characters in prefix", () =>
+    expect(strings.trimPrefix("file:///path/to/file", "file://")).toBe(
+      "/path/to/file",
+    ));
+
+  it("should handle unicode characters", () =>
+    expect(strings.trimPrefix("café au lait", "café ")).toBe("au lait"));
+
+  it("should handle numbers in prefix", () =>
+    expect(strings.trimPrefix("123abc", "123")).toBe("abc"));
+});

package/src/strings/strings.ts

@@ -87,3 +87,23 @@ export const createShortIdentifiers = (name: string): string[] => {
 
   return filteredIdentifiers;
 };
+
+/**
+ * Removes a prefix from a string if it exists.
+ *
+ * @param str - The string to remove the prefix from.
+ * @param prefix - The prefix to remove.
+ * @returns The string with the prefix removed if it was present, otherwise the original string.
+ *
+ * @example
+ * ```typescript
+ * trimPrefix("hello world", "hello "); // "world"
+ * trimPrefix("hello world", "goodbye "); // "hello world"
+ * trimPrefix("hello world", ""); // "hello world"
+ * trimPrefix("hello world", "hello world"); // ""
+ * ```
+ */
+export const trimPrefix = (str: string, prefix: string): string => {
+  if (str.startsWith(prefix)) return str.slice(prefix.length);
+  return str;
+};

package/src/telem/gl.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z } from "zod/v4";
+import { z } from "zod";
 
 export interface GLBufferController {
   createBuffer: () => WebGLBuffer | null;