@synnaxlabs/x 0.12.0 → 0.13.0

package/dist/{x.es.js → x.js}

@@ -3853,7 +3853,7 @@ const xLocation = z.enum(X_LOCATIONS);
 const Y_LOCATIONS = ["top", "bottom"];
 const yLocation = z.enum(Y_LOCATIONS);
 const CENTER_LOCATIONS = ["center"];
-z.enum(CENTER_LOCATIONS);
+const centerlocation = z.enum(CENTER_LOCATIONS);
 const LOCATIONS = [...OUTER_LOCATIONS, ...CENTER_LOCATIONS];
 const location$2 = z.enum(LOCATIONS);
 const alignment = z.enum(ALIGNMENTS);
@@ -4614,51 +4614,82 @@ const direction = (cl) => {
     return "y";
   return "x";
 };
-const xy$1 = z.object({ x: location$2, y: location$2 });
+const xy$1 = z.object({
+  x: xLocation.or(centerlocation),
+  y: yLocation.or(centerlocation)
+});
 const corner = z.object({ x: xLocation, y: yLocation });
-const TOP_LEFT = { x: "left", y: "top" };
-const TOP_RIGHT = { x: "right", y: "top" };
-const BOTTOM_LEFT = { x: "left", y: "bottom" };
-const BOTTOM_RIGHT = { x: "right", y: "bottom" };
-const CENTER = { x: "center", y: "center" };
-const TOP_CENTER = { x: "center", y: "top" };
-const BOTTOM_CENTER = { x: "center", y: "bottom" };
-const RIGHT_CENTER = { x: "right", y: "center" };
-const LEFT_CENTER = { x: "left", y: "center" };
+const TOP_LEFT = Object.freeze({ x: "left", y: "top" });
+const TOP_RIGHT = Object.freeze({ x: "right", y: "top" });
+const BOTTOM_LEFT = Object.freeze({ x: "left", y: "bottom" });
+const BOTTOM_RIGHT = Object.freeze({ x: "right", y: "bottom" });
+const CENTER = Object.freeze({ x: "center", y: "center" });
+const TOP_CENTER = Object.freeze({ x: "center", y: "top" });
+const BOTTOM_CENTER = Object.freeze({ x: "center", y: "bottom" });
+const RIGHT_CENTER = Object.freeze({ x: "right", y: "center" });
+const LEFT_CENTER = Object.freeze({ x: "left", y: "center" });
+const XY_LOCATIONS = Object.freeze([
+  LEFT_CENTER,
+  RIGHT_CENTER,
+  TOP_CENTER,
+  BOTTOM_CENTER,
+  TOP_LEFT,
+  TOP_RIGHT,
+  BOTTOM_LEFT,
+  BOTTOM_RIGHT,
+  CENTER
+]);
 const xyEquals = (a, b) => a.x === b.x && a.y === b.y;
+const xyMatches = (a, l) => {
+  if (typeof l === "object") {
+    let ok = true;
+    if ("x" in l) {
+      const ok_ = a.x === l.x;
+      if (!ok_)
+        ok = false;
+    }
+    if ("y" in l) {
+      const ok_ = a.y === l.y;
+      if (!ok_)
+        ok = false;
+    }
+    return ok;
+  }
+  return a.x === l || a.y === l;
+};
 const xyCouple = (a) => [a.x, a.y];
 const isX = (a) => direction(construct$3(a)) === "x";
 const isY = (a) => direction(construct$3(a)) === "y";
 const xyToString = (a) => `${a.x}${Case.capitalize(a.y)}`;
 const constructXY = (x2, y2) => {
-  let one;
-  let two;
+  let parsedX;
+  let parsedY;
   if (typeof x2 === "object" && "x" in x2) {
-    one = x2.x;
-    two = x2.y;
+    parsedX = x2.x;
+    parsedY = x2.y;
   } else {
-    one = construct$3(x2);
-    two = construct$3(y2 ?? x2);
+    parsedX = construct$3(x2);
+    parsedY = construct$3(y2 ?? x2);
   }
-  if (direction(one) === direction(two) && one !== "center" && two !== "center")
+  if (direction(parsedX) === direction(parsedY) && parsedX !== "center" && parsedY !== "center")
     throw new Error(
-      `[XYLocation] - encountered two locations with the same direction: ${one.toString()} - ${two.toString()}`
+      `[XYLocation] - encountered two locations with the same direction: ${parsedX.toString()} - ${parsedY.toString()}`
     );
-  const xy2 = CENTER;
-  if (one === "center") {
-    if (direction(two) === "x")
-      [xy2.x, xy2.y] = [two, one];
+  const xy2 = { ...CENTER };
+  if (parsedX === "center") {
+    if (isX(parsedY))
+      [xy2.x, xy2.y] = [parsedY, parsedX];
     else
-      [xy2.x, xy2.y] = [one, two];
-  } else if (two === "center") {
-    if (direction(one) === "x")
-      [xy2.x, xy2.y] = [one, two];
+      [xy2.x, xy2.y] = [parsedX, parsedY];
+  } else if (parsedY === "center") {
+    if (isX(parsedX))
+      [xy2.x, xy2.y] = [parsedX, parsedY];
     else
-      [xy2.x, xy2.y] = [two, one];
-  } else if (direction(one) === "x")
-    [xy2.x, xy2.y] = [one, two];
+      [xy2.x, xy2.y] = [parsedY, parsedX];
+  } else if (isX(parsedX))
+    [xy2.x, xy2.y] = [parsedX, parsedY];
   else
-    [xy2.x, xy2.y] = [two, one];
+    [xy2.x, xy2.y] = [parsedY, parsedX];
   return xy2;
 };
 const location = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -4673,6 +4704,7 @@ const location = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   TOP_CENTER,
   TOP_LEFT,
   TOP_RIGHT,
+  XY_LOCATIONS,
   X_LOCATIONS,
   Y_LOCATIONS,
   construct: construct$3,
@@ -4690,6 +4722,7 @@ const location = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   xy: xy$1,
   xyCouple,
   xyEquals,
+  xyMatches,
   xyToString,
   y: y$1
 }, Symbol.toStringTag, { value: "Module" }));
@@ -4702,6 +4735,13 @@ const crudeZ = z.union([
   clientXY
 ]);
 const construct$2 = (x2, y2) => {
+  if (typeof x2 === "string") {
+    if (y2 === void 0)
+      throw new Error("The y coordinate must be given.");
+    if (x2 === "x")
+      return { x: y2, y: 0 };
+    return { x: 0, y: y2 };
+  }
   if (typeof x2 === "number")
     return { x: x2, y: y2 ?? x2 };
   if (Array.isArray(x2))
@@ -4791,6 +4831,10 @@ const css$1 = (a) => {
   const xy2 = construct$2(a);
   return { left: xy2.x, top: xy2.y };
 };
+const truncate$1 = (a, precision = 0) => {
+  const xy2 = construct$2(a);
+  return { x: Number(xy2.x.toFixed(precision)), y: Number(xy2.y.toFixed(precision)) };
+};
 const xy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   INFINITY,
@@ -4813,6 +4857,7 @@ const xy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   translateX,
   translateY,
   translation,
+  truncate: truncate$1,
   xDistance,
   xy: xy$2,
   yDistance
@@ -4883,7 +4928,22 @@ const construct$1 = (first, second, width2 = 0, height2 = 0, coordinateRoot) =>
     b.two = second;
   return b;
 };
-const resize = (b, dims2) => construct$1(b.one, dims2);
+const resize = (b, dims2, amount) => {
+  const b_ = construct$1(b);
+  if (typeof dims2 === "string") {
+    if (amount == null)
+      throw new Error("Invalid arguments for resize");
+    const dir = construct$4(dims2);
+    return construct$1(
+      b_.one,
+      void 0,
+      dir === "x" ? amount : width(b_),
+      dir === "y" ? amount : height(b_),
+      b_.root
+    );
+  }
+  return construct$1(b_.one, dims2, void 0, void 0, b_.root);
+};
 const contains = (b, value) => {
   const b_ = construct$1(b);
   if ("one" in value)
@@ -4995,7 +5055,13 @@ const isBox = (value) => {
   return "one" in value && "two" in value && "root" in value;
 };
 const aspect = (b) => width(b) / height(b);
-const translate = (b, t) => {
+const translate = (b, t, amount) => {
+  if (typeof t === "string") {
+    if (amount == null)
+      throw new Error(`Undefined amount passed into box.translate`);
+    const dir = construct$4(t);
+    t = construct$2(dir, amount);
+  }
   const b_ = construct$1(b);
   return construct$1(
     translate$1(b_.one, t),
@@ -5005,10 +5071,52 @@ const translate = (b, t) => {
     b_.root
   );
 };
+const intersect = (a, b) => {
+  const x2 = Math.max(left(a), left(b));
+  const y2 = Math.max(top(a), top(b));
+  const x22 = Math.min(right(a), right(b));
+  const y22 = Math.min(bottom(a), bottom(b));
+  return construct$1({ x: x2, y: y2 }, { x: x22, y: y22 }, void 0, void 0, a.root);
+};
+const area = (b) => width(b) * height(b);
+const truncate = (b, precision = 0) => {
+  const b_ = construct$1(b);
+  return construct$1(
+    truncate$1(b_.one, precision),
+    truncate$1(b_.two, precision),
+    void 0,
+    void 0,
+    b_.root
+  );
+};
+const constructWithAlternateRoot = (x2, y2, width2, height2, currRoot, newRoot) => {
+  const first = { x: x2, y: y2 };
+  const second = { x: x2 + width2, y: y2 + height2 };
+  if (currRoot.x !== newRoot.x) {
+    if (currRoot.x === "center") {
+      first.x -= width2 / 2;
+      second.x -= width2 / 2;
+    } else {
+      first.x -= width2;
+      second.x -= width2;
+    }
+  }
+  if (currRoot.y !== newRoot.y) {
+    if (currRoot.y === "center") {
+      first.y -= height2 / 2;
+      second.y -= height2 / 2;
+    } else {
+      first.y -= height2;
+      second.y -= height2;
+    }
+  }
+  return construct$1(first, second, void 0, void 0, newRoot);
+};
 const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   DECIMAL: DECIMAL$1,
   ZERO: ZERO$1,
+  area,
   aspect,
   bottom,
   bottomLeft,
@@ -5016,6 +5124,7 @@ const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   box,
   center,
   construct: construct$1,
+  constructWithAlternateRoot,
   contains,
   copy: copy$1,
   css,
@@ -5023,6 +5132,7 @@ const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   dims,
   equals: equals$1,
   height,
+  intersect,
   isBox,
   isZero,
   left,
@@ -5041,6 +5151,7 @@ const box$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   topLeft,
   topRight,
   translate,
+  truncate,
   width,
   x,
   xBounds,
@@ -5383,6 +5494,131 @@ const scale = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   crudeXYTransform,
   xyScaleToTransform
 }, Symbol.toStringTag, { value: "Module" }));
+const posititonSoVisible = (target2, p) => {
+  const { width: width2, height: height2 } = target2.getBoundingClientRect();
+  const { innerWidth, innerHeight } = window;
+  let changed = false;
+  let nextXY = construct$2(p);
+  if (p.x + width2 > innerWidth) {
+    nextXY = translateX(nextXY, -width2);
+    changed = true;
+  }
+  if (p.y + height2 > innerHeight) {
+    nextXY = translateY(nextXY, -height2);
+    changed = true;
+  }
+  return [nextXY, changed];
+};
+const parseLocationOptions = (initial) => {
+  if (initial == null)
+    return { x: void 0, y: void 0 };
+  const parsedXYLoc = xy$1.safeParse(initial);
+  if (parsedXYLoc.success)
+    return parsedXYLoc.data;
+  const parsedLoc = location$2.safeParse(initial);
+  if (parsedLoc.success) {
+    const isX2 = construct$4(parsedLoc.data) === "x";
+    return isX2 ? { x: parsedLoc.data, y: void 0 } : { x: void 0, y: parsedLoc.data };
+  }
+  return initial;
+};
+const dialog = ({
+  container: containerCrude,
+  target: targetCrude,
+  dialog: dialogCrude,
+  initial,
+  prefer,
+  alignments = ["start"],
+  disable = []
+}) => {
+  const initialLocs = parseLocationOptions(initial);
+  let options2 = XY_LOCATIONS;
+  if (prefer != null) {
+    const parsedPrefer = prefer.map((p) => parseLocationOptions(p));
+    options2 = options2.slice().sort((a, b) => {
+      const hasPreferA = parsedPrefer.findIndex((p) => xyMatches(a, p));
+      const hasPreferB = parsedPrefer.findIndex((p) => xyMatches(b, p));
+      if (hasPreferA > -1 && hasPreferB > -1)
+        return hasPreferA - hasPreferB;
+      if (hasPreferA > -1)
+        return -1;
+      if (hasPreferB > -1)
+        return 1;
+      return 0;
+    });
+  }
+  const mappedOptions = options2.filter(
+    (l) => !xyEquals(l, CENTER) && (initialLocs.x == null || l.x === initialLocs.x) && (initialLocs.y == null || l.y === initialLocs.y) && !disable.some((d) => xyMatches(l, d))
+  ).map((l) => alignments == null ? void 0 : alignments.map((a) => [l, a])).flat();
+  const container = construct$1(containerCrude);
+  const target2 = construct$1(targetCrude);
+  const dialog2 = construct$1(dialogCrude);
+  let bestOptionArea = -Infinity;
+  const res = { location: CENTER, adjustedDialog: dialog2 };
+  mappedOptions.forEach(([option, alignment2]) => {
+    const [adjustedBox, area2] = evaluateOption({
+      option,
+      alignment: alignment2,
+      container,
+      target: target2,
+      dialog: dialog2
+    });
+    if (area2 > bestOptionArea) {
+      bestOptionArea = area2;
+      res.location = option;
+      res.adjustedDialog = adjustedBox;
+    }
+  });
+  return res;
+};
+const evaluateOption = ({
+  option,
+  alignment: alignment2,
+  container,
+  target: target2,
+  dialog: dialog2
+}) => {
+  const root2 = getRoot(option, alignment2);
+  const targetPoint = xyLoc(target2, option);
+  const dialogBox = constructWithAlternateRoot(
+    targetPoint.x,
+    targetPoint.y,
+    width(dialog2),
+    height(dialog2),
+    root2,
+    TOP_LEFT
+  );
+  const area$1 = area(intersect(dialogBox, container));
+  return [dialogBox, area$1];
+};
+const X_ALIGNMENT_MAP = {
+  start: "left",
+  center: "center",
+  end: "right"
+};
+const Y_ALIGNMENT_MAP = {
+  start: "bottom",
+  center: "center",
+  end: "top"
+};
+const getRoot = (option, alignment2) => {
+  const out = { x: "center", y: "center" };
+  if (option.y !== "center") {
+    out.y = swap$1(option.y);
+    const swapper = option.x === "left" ? swap$1 : (v) => v;
+    out.x = swapper(X_ALIGNMENT_MAP[alignment2]);
+  } else {
+    out.x = swap$1(option.x);
+    out.y = Y_ALIGNMENT_MAP[alignment2];
+  }
+  return out;
+};
+const position$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  dialog,
+  getRoot,
+  posititonSoVisible
+}, Symbol.toStringTag, { value: "Module" }));
 const spatial = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   ALIGNMENTS,
@@ -5641,6 +5877,9 @@ const _TimeStamp = class _TimeStamp extends Number {
   truncate(span2) {
     return this.sub(this.remainder(span2));
   }
+  get bigInt() {
+    return BigInt(this.valueOf());
+  }
   /**
    * @returns A new TimeStamp representing the current time in UTC. It's important to
    * note that this TimeStamp is only accurate to the millisecond level (that's the best
@@ -5712,6 +5951,18 @@ const _TimeSpan = class _TimeSpan extends Number {
     else
       super(value);
   }
+  lessThan(other) {
+    return this.valueOf() < new _TimeSpan(other).valueOf();
+  }
+  greaterThan(other) {
+    return this.valueOf() > new _TimeSpan(other).valueOf();
+  }
+  lessThanOrEqual(other) {
+    return this.valueOf() <= new _TimeSpan(other).valueOf();
+  }
+  greaterThanOrEqual(other) {
+    return this.valueOf() >= new _TimeSpan(other).valueOf();
+  }
   remainder(divisor) {
     return remainder(this, divisor);
   }
@@ -6109,6 +6360,14 @@ const _TimeRange = class _TimeRange {
   toPrettyString() {
     return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
   }
+  /**
+   * Checks if if the two time ranges overlap. If the two time ranges are equal, returns
+   * true.  If the start of one range is equal to the end of the other, returns false.
+   * Just follow the rule [start, end) i.e. start is inclusive and end is exclusive.
+   *
+   * @param other - The other TimeRange to compare to.
+   * @returns True if the two TimeRanges overlap, false otherwise.
+   */
   overlapsWith(other) {
     other = other.makeValid();
     const rng = this.makeValid();
@@ -6320,6 +6579,48 @@ const _Size = class _Size extends Number {
   sub(other) {
     return _Size.bytes(this.valueOf() - other.valueOf());
   }
+  truncate(span2) {
+    return new _Size(Math.trunc(this.valueOf() / span2.valueOf()) * span2.valueOf());
+  }
+  remainder(span2) {
+    return _Size.bytes(this.valueOf() % span2.valueOf());
+  }
+  get gigabytes() {
+    return this.valueOf() / _Size.GIGABYTE.valueOf();
+  }
+  get megabytes() {
+    return this.valueOf() / _Size.MEGABYTE.valueOf();
+  }
+  get kilobytes() {
+    return this.valueOf() / _Size.KILOBYTE.valueOf();
+  }
+  get terabytes() {
+    return this.valueOf() / _Size.TERABYTE.valueOf();
+  }
+  toString() {
+    const totalTB = this.truncate(_Size.TERABYTE);
+    const totalGB = this.truncate(_Size.GIGABYTE);
+    const totalMB = this.truncate(_Size.MEGABYTE);
+    const totalKB = this.truncate(_Size.KILOBYTE);
+    const totalB = this.truncate(_Size.BYTE);
+    const tb = totalTB;
+    const gb = totalGB.sub(totalTB);
+    const mb = totalMB.sub(totalGB);
+    const kb = totalKB.sub(totalMB);
+    const bytes = totalB.sub(totalKB);
+    let str = "";
+    if (!tb.isZero)
+      str += `${tb.terabytes}TB `;
+    if (!gb.isZero)
+      str += `${gb.gigabytes}GB `;
+    if (!mb.isZero)
+      str += `${mb.megabytes}MB `;
+    if (!kb.isZero)
+      str += `${kb.kilobytes}KB `;
+    if (!bytes.isZero || str === "")
+      str += `${bytes.valueOf()}B`;
+    return str.trim();
+  }
   /**
    * Creates a Size from the given number of bytes.
    *
@@ -6365,7 +6666,7 @@ const _Size = class _Size extends Number {
   static terabytes(value) {
     return _Size.gigabytes(value.valueOf() * 1e3);
   }
-  isZero() {
+  get isZero() {
     return this.valueOf() === 0;
   }
 };
@@ -6406,11 +6707,6 @@ const convertDataType = (source, target2, value, offset = 0) => {
     return BigInt(value) - BigInt(offset);
   return addSamples(value, -offset);
 };
-const validateFieldNotNull = (name, field) => {
-  if (field == null) {
-    throw new Error(`field ${name} is null`);
-  }
-};
 const FULL_BUFFER = -1;
 class Series {
   constructor({
@@ -6514,8 +6810,8 @@ class Series {
       throw new Error("cannot release an array with a negative reference count");
   }
   /**
-   * Writes the given series to this series. If the series being written exceeds the 
-   * remaining of series being written to, only the portion that fits will be written. 
+   * Writes the given series to this series. If the series being written exceeds the
+   * remaining of series being written to, only the portion that fits will be written.
    * @param other the series to write to this series. The data type of the series written
    * must be the same as the data type of the series being written to.
    * @returns the number of samples written. If the entire series fits, this value is
@@ -6570,7 +6866,8 @@ class Series {
   }
   /** @returns the time range of this array. */
   get timeRange() {
-    validateFieldNotNull("timeRange", this._timeRange);
+    if (this._timeRange == null)
+      throw new Error("time range not set on series");
     return this._timeRange;
   }
   /** @returns the capacity of the series in bytes. */
@@ -6752,7 +7049,8 @@ class Series {
       sampleOffset: this.sampleOffset,
       alignment: this.alignmentBounds,
       timeRange: (_a2 = this._timeRange) == null ? void 0 : _a2.toString(),
-      length: this.length
+      length: this.length,
+      capacity: this.capacity
     };
   }
   get memInfo() {
@@ -7014,10 +7312,42 @@ const memo = (func) => {
   };
   return v;
 };
+const difference = (obj1, obj2, path = "") => {
+  const diffMap = {};
+  const compare2 = (a, b, currentPath) => {
+    if (typeof a !== typeof b || a === null || b === null) {
+      diffMap[currentPath] = [a, b];
+      return;
+    }
+    if (typeof a === "object" && typeof b === "object") {
+      if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+          diffMap[currentPath] = [a, b];
+          return;
+        }
+        for (let i = 0; i < a.length; i++) {
+          compare2(a[i], b[i], `${currentPath}[${i}]`);
+        }
+      } else {
+        const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+        keys.forEach((key) => {
+          compare2(a[key], b[key], currentPath ? `${currentPath}.${key}` : key);
+        });
+      }
+    } else {
+      if (a !== b) {
+        diffMap[currentPath] = [a, b];
+      }
+    }
+  };
+  compare2(obj1, obj2, path);
+  return diffMap;
+};
 const external = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   copy,
   deleteD,
+  difference,
   element,
   equal,
   get,
@@ -9255,6 +9585,7 @@ const shallowCopy = (obj) => {
     return { ...obj };
   return obj;
 };
+const invert = (condition) => condition ? -1 : 1;
 export {
   Case,
   DataType,
@@ -9285,6 +9616,7 @@ export {
   dimensions,
   direction$1 as direction,
   getEntries,
+  invert,
   isObject,
   isStringer,
   types as kv,
@@ -9292,6 +9624,7 @@ export {
   nativeTypedArray,
   nullToArr,
   observe,
+  position$2 as position,
   primitiveIsZero,
   external$1 as runtime,
   scale,
@@ -9303,4 +9636,4 @@ export {
   unknownRecordZ,
   xy
 };
-//# sourceMappingURL=x.es.js.map
+//# sourceMappingURL=x.js.map