@synnaxlabs/x 0.44.3 → 0.45.0

package/dist/{xy-C_-hb3Q2.js → xy-DYPw8-8C.js}

@@ -1,9 +1,9 @@
-import { z as g } from "zod";
-import { x as p, n as w, d as I, s as A, i as M } from "./base-DFq0vvGn.js";
-const X = g.union([
-  g.number(),
+import { z as b } from "zod";
+import { x as p, n as v, d as I, s as A, j as M } from "./base-DRybODwJ.js";
+const E = b.union([
+  b.number(),
   p,
-  w,
+  v,
   I,
   A,
   M
@@ -13,10 +13,10 @@ const X = g.union([
     return t === "x" ? { x: n, y: 0 } : { x: 0, y: n };
   }
   return typeof t == "number" ? { x: t, y: n ?? t } : Array.isArray(t) ? { x: t[0], y: t[1] } : "signedWidth" in t ? { x: t.signedWidth, y: t.signedHeight } : "clientX" in t ? { x: t.clientX, y: t.clientY } : "width" in t ? { x: t.width, y: t.height } : { x: t.x, y: t.y };
-}, d = Object.freeze({ x: 0, y: 0 }), Y = Object.freeze({ x: 1, y: 1 }), Z = Object.freeze({ x: 1 / 0, y: 1 / 0 }), E = Object.freeze({ x: NaN, y: NaN }), O = (t, n, e = 0) => {
+}, d = Object.freeze({ x: 0, y: 0 }), T = Object.freeze({ x: 1, y: 1 }), X = Object.freeze({ x: 1 / 0, y: 1 / 0 }), Y = Object.freeze({ x: NaN, y: NaN }), O = (t, n, e = 0) => {
   const r = s(t), o = s(n);
   return e === 0 ? r.x === o.x && r.y === o.y : Math.abs(r.x - o.x) <= e && Math.abs(r.y - o.y) <= e;
-}, T = (t) => O(t, d), b = (t, n, e) => {
+}, Z = (t) => O(t, d), h = (t, n, e) => {
   const r = s(t), o = s(n, e);
   return { x: r.x * o.x, y: r.y * o.y };
 }, P = (t, n) => {
@@ -25,10 +25,20 @@ const X = g.union([
 }, _ = (t, n) => {
   const e = s(t);
   return { x: e.x, y: e.y + n };
-}, z = (t, n, e, ...r) => typeof n == "string" && typeof e == "number" ? n === "x" ? P(t, e) : _(t, e) : [t, n, e ?? d, ...r].reduce((o, y) => {
-  const c = s(y);
-  return { x: o.x + c.x, y: o.y + c.y };
-}, d), q = (t, n, e) => {
+}, j = (t, n, e, ...r) => {
+  if (typeof n == "string") {
+    if (typeof e != "number") throw new Error("The value must be a number.");
+    return n === "x" ? P(t, e) : _(t, e);
+  }
+  if (typeof n == "object" && "x" in n && typeof n.x == "string") {
+    const o = s(e), y = s(t);
+    return n.x === "left" ? o.x = -o.x : n.x === "center" && (o.x = 0), n.y === "top" ? o.y = -o.y : n.y === "center" && (o.y = 0), { x: y.x + o.x, y: y.y + o.y };
+  }
+  return [t, n, e ?? d, ...r].reduce((o, y) => {
+    const c = s(y);
+    return { x: o.x + c.x, y: o.y + c.y };
+  }, d);
+}, q = (t, n, e) => {
   const r = s(t);
   return n === "x" ? { x: e, y: r.y } : { x: r.x, y: e };
 }, H = (t, n) => {
@@ -58,12 +68,12 @@ const X = g.union([
 }, m = (t) => {
   const n = s(t), e = Math.hypot(n.x, n.y);
   return e === 0 ? { x: 0, y: 0 } : { x: -n.y / e, y: n.x / e };
-}, j = (t) => {
+}, w = (t) => {
   const n = s(t), e = Math.hypot(n.x, n.y);
   return e === 0 ? { x: 0, y: 0 } : { x: n.x / e, y: n.y / e };
-}, F = (...t) => {
-  const n = t.reduce((e, r) => z(e, r), d);
-  return b(n, 1 / t.length);
+}, z = (...t) => {
+  const n = t.reduce((e, r) => j(e, r), d);
+  return h(n, 1 / t.length);
 }, $ = (t, n) => {
   const e = [];
   for (let r = 0; r < t.length; r++) {
@@ -78,12 +88,12 @@ const X = g.union([
     } else {
       const x = t[r - 1], u = t[r + 1], a = f(o, x), l = f(u, o);
       y = m(a), c = m(l);
-      const v = Math.acos(
+      const F = Math.acos(
         (a.x * l.x + a.y * l.y) / (Math.hypot(a.x, a.y) * Math.hypot(l.x, l.y))
-      ), h = Math.sin(v / 2);
-      h === 0 ? i = n : i = n / h, N = j(F(y, c));
+      ), g = Math.sin(F / 2);
+      g === 0 ? i = n : i = n / g, N = w(z(y, c));
     }
-    e.push(b(N, i));
+    e.push(h(N, i));
   }
   return e;
 }, k = (t) => {
@@ -94,30 +104,30 @@ const X = g.union([
   return { x: Math.round(n.x), y: Math.round(n.y) };
 }, K = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  INFINITY: Z,
-  NAN: E,
-  ONE: Y,
+  INFINITY: X,
+  NAN: Y,
+  ONE: T,
   ZERO: d,
-  average: F,
+  average: z,
   calculateMiters: $,
   clientXY: M,
   construct: s,
   couple: D,
-  crudeZ: X,
+  crudeZ: E,
   css: L,
   distance: H,
   equals: O,
   isFinite: C,
   isNan: W,
-  isZero: T,
+  isZero: Z,
   normal: m,
-  normalize: j,
+  normalize: w,
   round: B,
-  scale: b,
+  scale: h,
   set: q,
   sub: f,
   swap: k,
-  translate: z,
+  translate: j,
   translateX: P,
   translateY: _,
   translation: S,
@@ -125,13 +135,13 @@ const X = g.union([
   xy: p
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  Y as O,
+  T as O,
   d as Z,
   R as a,
-  X as b,
+  E as b,
   s as c,
   O as e,
   B as r,
-  z as t,
+  j as t,
   K as x
 };

package/dist/xy.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./xy-CUE3QDNn.cjs");exports.xy=e.xy;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./xy-DWwtHmgn.cjs");exports.xy=e.xy;

package/dist/xy.js

@@ -1,4 +1,4 @@
-import { x as r } from "./xy-C_-hb3Q2.js";
+import { x as r } from "./xy-DYPw8-8C.js";
 export {
   r as xy
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.44.3",
+  "version": "0.45.0",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
-  "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",
+  "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/ts",
   "keywords": [
     "synnax",
     "utilities",
@@ -95,11 +95,6 @@
       "import": "./dist/location.js",
       "require": "./dist/location.cjs"
     },
-    "./position": {
-      "types": "./dist/src/spatial/position/index.d.ts",
-      "import": "./dist/position.js",
-      "require": "./dist/position.cjs"
-    },
     "./scale": {
       "types": "./dist/src/spatial/scale/index.d.ts",
       "import": "./dist/scale.js",

package/src/caseconv/caseconv.spec.ts

@@ -127,4 +127,34 @@ describe("caseconv", () => {
       });
     });
   });
+  describe("toProperNoun", () => {
+    const SPECS: [string, string][] = [
+      ["fooBar", "Foo Bar"],
+      ["foo_bar", "Foo Bar"],
+      ["foo-bar", "Foo Bar"],
+      ["FooBar", "Foo Bar"],
+      ["foo_bar_baz", "Foo Bar Baz"],
+      ["fooBarBaz", "Foo Bar Baz"],
+      ["foo-bar-baz", "Foo Bar Baz"],
+      ["XMLParser", "XML Parser"],
+      ["parseXMLDocument", "Parse XML Document"],
+      ["IODevice", "IO Device"],
+      ["temperature_sensor", "Temperature Sensor"],
+      ["pressure-gauge", "Pressure Gauge"],
+      ["flowMeter", "Flow Meter"],
+      ["my_custom_symbol", "My Custom Symbol"],
+      ["valve-actuator-v2", "Valve Actuator V2"],
+      ["PIDController", "PID Controller"],
+      ["", ""],
+      ["a", "A"],
+      ["ABC", "ABC"],
+      ["test123value", "Test123value"],
+      ["test_123_value", "Test 123 Value"],
+    ];
+    SPECS.forEach(([input, expected]) => {
+      it(`should convert ${input} to ${expected}`, () => {
+        expect(caseconv.toProperNoun(input)).toBe(expected);
+      });
+    });
+  });
 });

package/src/caseconv/caseconv.ts

@@ -165,3 +165,49 @@ const toKebabStr = (str: string): string =>
  * @returns The converted string in kebab-case
  */
 export const toKebab = createConverter(toKebabStr);
+
+/**
+ * Converts a string to proper noun format.
+ * Handles snake_case, kebab-case, camelCase, and PascalCase.
+ * Capitalizes the first letter of each word.
+ *
+ * @param str - The string to convert
+ * @returns The converted string in proper noun format
+ */
+const toProperNounStr = (str: string): string => {
+  if (str.length === 0) return str;
+  
+  // Replace underscores and hyphens with spaces
+  let result = str.replace(/[_-]/g, " ");
+  
+  // Insert spaces before capital letters (for camelCase/PascalCase)
+  // but not at the start or when there are consecutive capitals
+  result = result.replace(
+    /([a-z0-9])([A-Z])/g,
+    (_, p1: string, p2: string) => `${p1} ${p2}`
+  );
+  
+  // Handle consecutive capitals (e.g., "XMLParser" -> "XML Parser")
+  result = result.replace(
+    /([A-Z]+)([A-Z][a-z])/g,
+    (_, p1: string, p2: string) => `${p1} ${p2}`
+  );
+  
+  // Clean up multiple spaces
+  result = result.replace(/\s+/g, " ").trim();
+  
+  // Capitalize first letter of each word (proper noun format)
+  result = result.replace(/\b\w/g, (char) => char.toUpperCase());
+  
+  return result;
+};
+
+/**
+ * Converts a string to proper noun format.
+ * Handles snake_case, kebab-case, camelCase, and PascalCase.
+ * Each word is capitalized.
+ *
+ * @param str - The string to convert
+ * @returns The converted string in proper noun format
+ */
+export const toProperNoun = createConverter(toProperNounStr);

package/src/color/color.spec.ts

@@ -757,6 +757,46 @@ describe("color.Color", () => {
     });
   });
 
+  describe("fromCSS", () => {
+    test("parses hex colors", () => {
+      expect(color.fromCSS("#ff0000")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("#00ff00")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("#0000ff")).toEqual([0, 0, 255, 1]);
+      expect(color.fromCSS("#f00")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("#0f0")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("#00f")).toEqual([0, 0, 255, 1]);
+    });
+
+    test("parses rgb/rgba colors", () => {
+      expect(color.fromCSS("rgb(255, 0, 0)")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("rgb(0, 255, 0)")).toEqual([0, 255, 0, 1]);
+      expect(color.fromCSS("rgba(0, 0, 255, 0.5)")).toEqual([0, 0, 255, 0.5]);
+      expect(color.fromCSS("rgba(128, 128, 128, 1)")).toEqual([128, 128, 128, 1]);
+    });
+
+    test("parses named colors", () => {
+      expect(color.fromCSS("red")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("green")).toEqual([0, 128, 0, 1]);
+      expect(color.fromCSS("blue")).toEqual([0, 0, 255, 1]);
+      expect(color.fromCSS("black")).toEqual([0, 0, 0, 1]);
+      expect(color.fromCSS("white")).toEqual([255, 255, 255, 1]);
+    });
+
+    test("handles case insensitive input", () => {
+      expect(color.fromCSS("RED")).toEqual([255, 0, 0, 1]);
+      expect(color.fromCSS("Green")).toEqual([0, 128, 0, 1]);
+      expect(color.fromCSS("BLUE")).toEqual([0, 0, 255, 1]);
+    });
+
+    test("returns undefined for invalid input", () => {
+      expect(color.fromCSS("")).toBeUndefined();
+      expect(color.fromCSS("none")).toBeUndefined();
+      expect(color.fromCSS("transparent")).toBeUndefined();
+      expect(color.fromCSS("invalid")).toBeUndefined();
+      expect(color.fromCSS("#gggggg")).toBeUndefined();
+    });
+  });
+
   describe("isZero", () => {
     test("returns true for zero color", () => {
       expect(color.isZero([0, 0, 0, 0])).toBe(true);

package/src/color/color.ts

@@ -282,6 +282,78 @@ const rgbaToHex = (n: number): string => Math.floor(n).toString(16).padStart(2,
 const hexToRgba = (s: string, n: number): number => parseInt(s.slice(n, n + 2), 16);
 const stripHash = (hex: string): string => (hex.startsWith("#") ? hex.slice(1) : hex);
 
+const NAMED: Record<string, string> = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  silver: "#c0c0c0",
+  gray: "#808080",
+  grey: "#808080",
+  maroon: "#800000",
+  olive: "#808000",
+  lime: "#00ff00",
+  aqua: "#00ffff",
+  teal: "#008080",
+  navy: "#000080",
+  fuchsia: "#ff00ff",
+  purple: "#800080",
+  orange: "#ffa500",
+  brown: "#a52a2a",
+  tan: "#d2b48c",
+  gold: "#ffd700",
+  indigo: "#4b0082",
+  violet: "#ee82ee",
+  pink: "#ffc0cb",
+  coral: "#ff7f50",
+  salmon: "#fa8072",
+  khaki: "#f0e68c",
+  crimson: "#dc143c",
+  transparent: "transparent",
+};
+
+/**
+ * Parses a CSS color string into a Color.
+ * Supports hex colors, rgb/rgba functions, and named colors.
+ * @param cssColor - The CSS color string to parse
+ * @returns The parsed color or undefined if invalid
+ */
+export const fromCSS = (cssColor: string): Color | undefined => {
+  if (!cssColor) return undefined;
+  const trimmed = cssColor.trim().toLowerCase();
+  if (trimmed === "transparent" || trimmed === "none") return undefined;
+  if (trimmed.startsWith("#")) {
+    if (trimmed.length === 4) {
+      const r = trimmed[1];
+      const g = trimmed[2];
+      const b = trimmed[3];
+      const expanded = `#${r}${r}${g}${g}${b}${b}`;
+      if (hexZ.safeParse(expanded).success) return fromHex(expanded);
+    }
+    if (
+      (trimmed.length === 7 || trimmed.length === 9) &&
+      hexZ.safeParse(trimmed).success
+    )
+      return fromHex(trimmed);
+    return undefined;
+  }
+  if (trimmed.startsWith("rgb")) {
+    const match = trimmed.match(
+      /rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/,
+    );
+    if (match) {
+      const [, r, g, b, a] = match;
+      return [parseInt(r), parseInt(g), parseInt(b), a ? parseFloat(a) : 1];
+    }
+  }
+  if (NAMED[trimmed]) return fromHex(NAMED[trimmed]);
+  return undefined;
+};
+
 /** @returns parse a color from an HSLA tuple. */
 export const fromHSLA = (hsla: HSLA): RGBA => {
   hsla = hslaZ.parse(hsla);

package/src/index.ts

@@ -49,6 +49,7 @@ export * from "@/sync";
 export * from "@/telem";
 export * from "@/testutil";
 export * from "@/transform";
+export * from "@/undefined";
 export * from "@/unique";
 export * from "@/url";
 export * from "@/uuid";

package/src/primitive/primitive.spec.ts

@@ -124,6 +124,15 @@ describe("primitive", () => {
         });
         expect(decoded.myDog).toBeInstanceOf(MyValueExtension);
       });
+
+      describe("isCrudeValueExtension", () => {
+        it("should return true for a CrudeValueExtension", () => {
+          expect(primitive.isCrudeValueExtension({ value: 12n })).toEqual(true);
+        });
+        it("should return false for a non-CrudeValueExtension", () => {
+          expect(primitive.isCrudeValueExtension(12n)).toEqual(false);
+        });
+      });
     });
   });
 });

package/src/primitive/primitive.ts

@@ -10,6 +10,15 @@
 /** Union of types that are primitive values or can be converted to primitive values */
 export type Value = string | number | bigint | boolean | Stringer | null | undefined;
 
+export type CrudeValueExtension<V extends NonNullable<Value>> = {
+  value: V;
+};
+
+export const isCrudeValueExtension = <V extends NonNullable<Value>>(
+  value: unknown,
+): value is CrudeValueExtension<V> =>
+  value != null && typeof value === "object" && "value" in value;
+
 /**
  * ValueExtension is a utility class that can be extended in order to implement objects
  * that pseudo-extend a primitive value with additional functionality.

package/src/record/record.spec.ts

@@ -316,4 +316,35 @@ describe("record", () => {
       });
     });
   });
+
+  describe("omit", () => {
+    type Object = { [key: string]: number };
+    it("should return the object if no keys are provided", () =>
+      expect(record.omit({ a: 1, b: 2, c: 3 })).toEqual({ a: 1, b: 2, c: 3 }));
+
+    it("should return the object for a single key", () =>
+      expect(record.omit({ a: 1, b: 2, c: 3 }, "a")).toEqual({ b: 2, c: 3 }));
+
+    it("should return the object for multiple keys", () =>
+      expect(record.omit({ a: 1, b: 2, c: 3 }, "a", "b")).toEqual({ c: 3 }));
+
+    it("should not mutate the original object", () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      const result = record.omit(obj, "a", "b");
+      expect(result).toEqual({ c: 3 });
+      expect(obj).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it("should be a no-op if the keys are not present", () => {
+      const obj: Object = { a: 1, b: 2, c: 3 };
+      const result = record.omit(obj, "d", "e");
+      expect(result).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it("should handle empty objects", () => {
+      const obj: Object = {};
+      const result = record.omit(obj, "a", "b", "c");
+      expect(result).toEqual({});
+    });
+  });
 });

package/src/record/record.ts

@@ -116,3 +116,26 @@ export const map = <T extends Record<Key, unknown>, U>(
  */
 export const purgeUndefined = <T extends Record<Key, unknown>>(obj: T): T =>
   Object.fromEntries(entries(obj).filter(([_, value]) => value !== undefined)) as T;
+
+/**
+ * Removes specified keys from an object. This creates a shallow copy of the object and
+ * removes the keys instead of mutating the original object.
+ *
+ * @template T - The type of the input object
+ * @template K - The type of the keys to remove
+ * @param obj - The object to remove keys from
+ * @param keys - The keys to remove from the object
+ * @returns A new object with the specified keys removed
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const omitted = record.omit(obj, "b", "c");
+ * // Result: { a: 1 }
+ * ```
+ */
+export const omit = <T, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> => {
+  const result = { ...obj };
+  for (const key of keys) delete result[key];
+  return result;
+};

package/src/spatial/base.ts

@@ -83,6 +83,10 @@ export type CrudeBounds<T extends number | bigint = number> =
   | Bounds<T>
   | NumberCouple<T>;
 export const crudeDirection = z.enum([...direction.options, ...location.options]);
+export const crudeXDirection = z.enum(["x", "left", "right"]);
+export const crudeYDirection = z.enum(["y", "top", "bottom"]);
 export type CrudeDirection = z.infer<typeof crudeDirection>;
+export type CrudeXDirection = z.infer<typeof crudeXDirection>;
+export type CrudeYDirection = z.infer<typeof crudeYDirection>;
 export const crudeLocation = z.union([direction, location, z.instanceof(String)]);
 export type CrudeLocation = z.infer<typeof crudeLocation>;

package/src/spatial/direction/direction.spec.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 { describe, expect, test } from "vitest";
+import { describe, expect, it, test } from "vitest";
 
 import * as direction from "@/spatial/direction/direction";
 
@@ -22,4 +22,38 @@ describe("Direction", () => {
       test(name, () => expect(direction.construct(arg)).toEqual("y")),
     );
   });
+
+  describe("isX", () => {
+    const TESTS: [direction.Crude, boolean][] = [
+      ["x", true],
+      ["y", false],
+      ["left", true],
+      ["right", true],
+      ["top", false],
+      ["bottom", false],
+      ["center", false],
+    ];
+    TESTS.forEach(([arg, expected]) => {
+      it(`should return ${expected} for ${arg}`, () => {
+        expect(direction.isX(arg)).toBe(expected);
+      });
+    });
+  });
+
+  describe("isY", () => {
+    const TESTS: [direction.Crude, boolean][] = [
+      ["x", false],
+      ["y", true],
+      ["left", false],
+      ["right", false],
+      ["top", true],
+      ["bottom", true],
+      ["center", false],
+    ];
+    TESTS.forEach(([arg, expected]) => {
+      it(`should return ${expected} for ${arg}`, () => {
+        expect(direction.isY(arg)).toBe(expected);
+      });
+    });
+  });
 });

package/src/spatial/direction/direction.ts

@@ -10,6 +10,8 @@
 import {
   type CrudeDirection,
   crudeDirection,
+  type CrudeXDirection,
+  type CrudeYDirection,
   type Dimension,
   type Direction,
   direction,
@@ -25,6 +27,8 @@ export { Direction, direction, DIRECTIONS };
 export const crude = crudeDirection;
 
 export type Crude = CrudeDirection;
+export type CrudeX = CrudeXDirection;
+export type CrudeY = CrudeYDirection;
 
 export const construct = (c: Crude): Direction => {
   if (DIRECTIONS.includes(c as Direction)) return c as Direction;
@@ -45,3 +49,11 @@ export const isDirection = (c: unknown): c is Direction => crude.safeParse(c).su
 
 export const signedDimension = (direction: CrudeDirection): SignedDimension =>
   construct(direction) === "x" ? "signedWidth" : "signedHeight";
+
+export const isX = (direction: CrudeDirection): direction is CrudeXDirection => {
+  if (direction === "center") return false;
+  return construct(direction) === "x";
+};
+
+export const isY = (direction: CrudeDirection): direction is CrudeYDirection =>
+  construct(direction) === "y";

package/src/spatial/external.ts

@@ -12,7 +12,6 @@ export { box } from "@/spatial/box";
 export * from "@/spatial/dimensions";
 export * from "@/spatial/direction";
 export * from "@/spatial/location";
-export * from "@/spatial/position";
 export * from "@/spatial/scale";
 export * as spatial from "@/spatial/spatial";
 export * from "@/spatial/xy";

package/src/spatial/location/location.ts

@@ -20,6 +20,7 @@ import {
   DIRECTIONS,
   type Location,
   location,
+  OUTER_LOCATIONS,
   type OuterLocation,
   outerLocation,
   X_LOCATIONS,
@@ -35,6 +36,7 @@ export {
   type Location,
   location,
   outerLocation as outer,
+  OUTER_LOCATIONS,
   X_LOCATIONS,
   Y_LOCATIONS,
 };