tgui-core 1.1.11 → 1.1.13

package/dist/common/constants.js

@@ -0,0 +1,312 @@
+const t = 2, n = 1, i = 0, m = -1, c = {
+  // Department colors
+  department: {
+    captain: "#c06616",
+    security: "#e74c3c",
+    medbay: "#3498db",
+    science: "#9b59b6",
+    engineering: "#f1c40f",
+    cargo: "#f39c12",
+    service: "#7cc46a",
+    centcom: "#00c100",
+    other: "#c38312"
+  },
+  // Damage type colors
+  damageType: {
+    oxy: "#3498db",
+    toxin: "#2ecc71",
+    burn: "#e67e22",
+    brute: "#e74c3c"
+  },
+  // reagent / chemistry related colours
+  reagent: {
+    acidicbuffer: "#fbc314",
+    basicbuffer: "#3853a4"
+  }
+}, u = [
+  "average",
+  "bad",
+  "black",
+  "blue",
+  "brown",
+  "good",
+  "green",
+  "grey",
+  "label",
+  "olive",
+  "orange",
+  "pink",
+  "purple",
+  "red",
+  "teal",
+  "transparent",
+  "violet",
+  "white",
+  "yellow"
+], d = [
+  {
+    name: "Syndicate",
+    freq: 1213,
+    color: "#8f4a4b"
+  },
+  {
+    name: "Red Team",
+    freq: 1215,
+    color: "#ff4444"
+  },
+  {
+    name: "Blue Team",
+    freq: 1217,
+    color: "#3434fd"
+  },
+  {
+    name: "Green Team",
+    freq: 1219,
+    color: "#34fd34"
+  },
+  {
+    name: "Yellow Team",
+    freq: 1221,
+    color: "#fdfd34"
+  },
+  {
+    name: "CentCom",
+    freq: 1337,
+    color: "#2681a5"
+  },
+  {
+    name: "Supply",
+    freq: 1347,
+    color: "#b88646"
+  },
+  {
+    name: "Service",
+    freq: 1349,
+    color: "#6ca729"
+  },
+  {
+    name: "Science",
+    freq: 1351,
+    color: "#c68cfa"
+  },
+  {
+    name: "Command",
+    freq: 1353,
+    color: "#fcdf03"
+  },
+  {
+    name: "Medical",
+    freq: 1355,
+    color: "#57b8f0"
+  },
+  {
+    name: "Engineering",
+    freq: 1357,
+    color: "#f37746"
+  },
+  {
+    name: "Security",
+    freq: 1359,
+    color: "#dd3535"
+  },
+  {
+    name: "AI Private",
+    freq: 1447,
+    color: "#d65d95"
+  },
+  {
+    name: "Common",
+    freq: 1459,
+    color: "#1ecc43"
+  }
+], e = [
+  {
+    id: "o2",
+    path: "/datum/gas/oxygen",
+    name: "Oxygen",
+    label: "O₂",
+    color: "blue"
+  },
+  {
+    id: "n2",
+    path: "/datum/gas/nitrogen",
+    name: "Nitrogen",
+    label: "N₂",
+    color: "yellow"
+  },
+  {
+    id: "co2",
+    path: "/datum/gas/carbon_dioxide",
+    name: "Carbon Dioxide",
+    label: "CO₂",
+    color: "grey"
+  },
+  {
+    id: "plasma",
+    path: "/datum/gas/plasma",
+    name: "Plasma",
+    label: "Plasma",
+    color: "pink"
+  },
+  {
+    id: "water_vapor",
+    path: "/datum/gas/water_vapor",
+    name: "Water Vapor",
+    label: "H₂O",
+    color: "lightsteelblue"
+  },
+  {
+    id: "hypernoblium",
+    path: "/datum/gas/hypernoblium",
+    name: "Hyper-noblium",
+    label: "Hyper-nob",
+    color: "teal"
+  },
+  {
+    id: "n2o",
+    path: "/datum/gas/nitrous_oxide",
+    name: "Nitrous Oxide",
+    label: "N₂O",
+    color: "bisque"
+  },
+  {
+    id: "no2",
+    path: "/datum/gas/nitrium",
+    name: "Nitrium",
+    label: "Nitrium",
+    color: "brown"
+  },
+  {
+    id: "tritium",
+    path: "/datum/gas/tritium",
+    name: "Tritium",
+    label: "Tritium",
+    color: "limegreen"
+  },
+  {
+    id: "bz",
+    path: "/datum/gas/bz",
+    name: "BZ",
+    label: "BZ",
+    color: "mediumpurple"
+  },
+  {
+    id: "pluoxium",
+    path: "/datum/gas/pluoxium",
+    name: "Pluoxium",
+    label: "Pluoxium",
+    color: "mediumslateblue"
+  },
+  {
+    id: "miasma",
+    path: "/datum/gas/miasma",
+    name: "Miasma",
+    label: "Miasma",
+    color: "olive"
+  },
+  {
+    id: "freon",
+    path: "/datum/gas/freon",
+    name: "Freon",
+    label: "Freon",
+    color: "paleturquoise"
+  },
+  {
+    id: "hydrogen",
+    path: "/datum/gas/hydrogen",
+    name: "Hydrogen",
+    label: "H₂",
+    color: "white"
+  },
+  {
+    id: "healium",
+    path: "/datum/gas/healium",
+    name: "Healium",
+    label: "Healium",
+    color: "salmon"
+  },
+  {
+    id: "proto_nitrate",
+    path: "/datum/gas/proto_nitrate",
+    name: "Proto Nitrate",
+    label: "Proto-Nitrate",
+    color: "greenyellow"
+  },
+  {
+    id: "zauker",
+    path: "/datum/gas/zauker",
+    name: "Zauker",
+    label: "Zauker",
+    color: "darkgreen"
+  },
+  {
+    id: "halon",
+    path: "/datum/gas/halon",
+    name: "Halon",
+    label: "Halon",
+    color: "purple"
+  },
+  {
+    id: "helium",
+    path: "/datum/gas/helium",
+    name: "Helium",
+    label: "He",
+    color: "aliceblue"
+  },
+  {
+    id: "antinoblium",
+    path: "/datum/gas/antinoblium",
+    name: "Antinoblium",
+    label: "Anti-Noblium",
+    color: "maroon"
+  },
+  {
+    id: "nitrium",
+    path: "/datum/gas/nitrium",
+    name: "Nitrium",
+    label: "Nitrium",
+    color: "brown"
+  }
+];
+function b(a, o) {
+  if (!a) return o || "None";
+  const r = a.toLowerCase();
+  for (let l = 0; l < e.length; l++)
+    if (e[l].id === r)
+      return e[l].label;
+  return o || "None";
+}
+function s(a) {
+  if (!a) return "black";
+  const o = a.toLowerCase();
+  for (let r = 0; r < e.length; r++)
+    if (e[r].id === o)
+      return e[r].color;
+  return "black";
+}
+const g = (a) => {
+  if (!a) return;
+  const o = a.toLowerCase();
+  for (let r = 0; r < e.length; r++)
+    if (e[r].id === o)
+      return e[r];
+}, p = (a) => {
+  if (a) {
+    for (let o = 0; o < e.length; o++)
+      if (e[o].path === a)
+        return e[o];
+  }
+};
+export {
+  c as COLORS,
+  u as CSS_COLORS,
+  d as RADIO_CHANNELS,
+  m as UI_CLOSE,
+  i as UI_DISABLED,
+  t as UI_INTERACTIVE,
+  n as UI_UPDATE,
+  s as getGasColor,
+  g as getGasFromId,
+  p as getGasFromPath,
+  b as getGasLabel
+};

package/dist/common/events.d.ts

@@ -0,0 +1,33 @@
+type Fn = (...args: any[]) => void;
+export declare class EventEmitter {
+    private listeners;
+    constructor();
+    on(name: string, listener: Fn): void;
+    off(name: string, listener: Fn): void;
+    emit(name: string, ...params: any[]): void;
+    clear(): void;
+}
+export declare const globalEvents: EventEmitter;
+export declare const setupGlobalEvents: (options?: {
+    ignoreWindowFocus?: boolean;
+}) => void;
+export declare function canStealFocus(node: HTMLElement): boolean;
+export declare function addScrollableNode(node: HTMLElement): void;
+export declare function removeScrollableNode(node: HTMLElement): void;
+export declare class KeyEvent {
+    event: KeyboardEvent;
+    type: 'keydown' | 'keyup';
+    code: number;
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    repeat: boolean;
+    _str?: string;
+    constructor(e: KeyboardEvent, type: 'keydown' | 'keyup', repeat?: boolean);
+    hasModifierKeys(): boolean;
+    isModifierKey(): boolean;
+    isDown(): boolean;
+    isUp(): boolean;
+    toString(): string;
+}
+export {};

package/dist/common/events.js

@@ -0,0 +1,147 @@
+var _ = Object.defineProperty;
+var v = (t, e, s) => e in t ? _(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var i = (t, e, s) => v(t, typeof e != "symbol" ? e + "" : e, s);
+import { KEY_CTRL as F, KEY_SHIFT as L, KEY_ALT as b, KEY_F1 as K, KEY_F12 as S } from "./keycodes.js";
+class C {
+  constructor() {
+    i(this, "listeners");
+    this.listeners = {};
+  }
+  on(e, s) {
+    this.listeners[e] = this.listeners[e] || [], this.listeners[e].push(s);
+  }
+  off(e, s) {
+    const n = this.listeners[e];
+    if (!n)
+      throw new Error(`There is no listeners for "${e}"`);
+    this.listeners[e] = n.filter((l) => l !== s);
+  }
+  emit(e, ...s) {
+    const n = this.listeners[e];
+    if (n)
+      for (let l = 0, k = n.length; l < k; l += 1) {
+        const g = n[l];
+        g(...s);
+      }
+  }
+  clear() {
+    this.listeners = {};
+  }
+}
+const o = new C();
+let m = !1;
+const W = (t = {}) => {
+  m = !!t.ignoreWindowFocus;
+};
+let d, f = !0;
+function u(t, e) {
+  if (m) {
+    f = !0;
+    return;
+  }
+  if (d && (clearTimeout(d), d = null), e) {
+    d = setTimeout(() => u(t));
+    return;
+  }
+  f !== t && (f = t, o.emit(t ? "window-focus" : "window-blur"), o.emit("window-focus-change", t));
+}
+let r = null;
+function E(t) {
+  const e = String(t.tagName).toLowerCase();
+  return e === "input" || e === "textarea";
+}
+function T(t) {
+  a(), r = t, r.addEventListener("blur", a);
+}
+function a() {
+  r && (r.removeEventListener("blur", a), r = null);
+}
+let w = null, c = null;
+const h = [];
+function A(t) {
+  h.push(t);
+}
+function B(t) {
+  const e = h.indexOf(t);
+  e >= 0 && h.splice(e, 1);
+}
+function N(t) {
+  if (r || !f)
+    return;
+  const e = document.body;
+  for (; t && t !== e; ) {
+    if (h.includes(t)) {
+      if (t.contains(w))
+        return;
+      w = t, t.focus();
+      return;
+    }
+    t = t.parentElement;
+  }
+}
+window.addEventListener("mousemove", (t) => {
+  const e = t.target;
+  e !== c && (c = e, N(e));
+});
+window.addEventListener("focusin", (t) => {
+  c = null, w = t.target, u(!0), E(t.target) && T(t.target);
+});
+window.addEventListener("focusout", () => {
+  c = null, u(!1, !0);
+});
+window.addEventListener("blur", () => {
+  c = null, u(!1, !0);
+});
+window.addEventListener("beforeunload", () => {
+  u(!1);
+});
+const y = {};
+class p {
+  constructor(e, s, n) {
+    i(this, "event");
+    i(this, "type");
+    i(this, "code");
+    i(this, "ctrl");
+    i(this, "shift");
+    i(this, "alt");
+    i(this, "repeat");
+    i(this, "_str");
+    this.event = e, this.type = s, this.code = e.keyCode, this.ctrl = e.ctrlKey, this.shift = e.shiftKey, this.alt = e.altKey, this.repeat = !!n;
+  }
+  hasModifierKeys() {
+    return this.ctrl || this.alt || this.shift;
+  }
+  isModifierKey() {
+    return this.code === F || this.code === L || this.code === b;
+  }
+  isDown() {
+    return this.type === "keydown";
+  }
+  isUp() {
+    return this.type === "keyup";
+  }
+  toString() {
+    return this._str ? this._str : (this._str = "", this.ctrl && (this._str += "Ctrl+"), this.alt && (this._str += "Alt+"), this.shift && (this._str += "Shift+"), this.code >= 48 && this.code <= 90 ? this._str += String.fromCharCode(this.code) : this.code >= K && this.code <= S ? this._str += "F" + (this.code - 111) : this._str += "[" + this.code + "]", this._str);
+  }
+}
+document.addEventListener("keydown", (t) => {
+  if (E(t.target))
+    return;
+  const e = t.keyCode, s = new p(t, "keydown", y[e]);
+  o.emit("keydown", s), o.emit("key", s), y[e] = !0;
+});
+document.addEventListener("keyup", (t) => {
+  if (E(t.target))
+    return;
+  const e = t.keyCode, s = new p(t, "keyup");
+  o.emit("keyup", s), o.emit("key", s), y[e] = !1;
+});
+export {
+  C as EventEmitter,
+  p as KeyEvent,
+  A as addScrollableNode,
+  E as canStealFocus,
+  o as globalEvents,
+  B as removeScrollableNode,
+  W as setupGlobalEvents
+};

package/{lib/common/exhaustive.ts → dist/common/exhaustive.d.ts}

@@ -14,6 +14,4 @@
  *    exhaustiveCheck(color);
  * }
  */
-export function exhaustiveCheck(input: never) {
-  throw new Error(`Unhandled case: ${input}`);
-}
+export declare function exhaustiveCheck(input: never): void;

package/dist/common/exhaustive.js

@@ -0,0 +1,6 @@
+function n(e) {
+  throw new Error(`Unhandled case: ${e}`);
+}
+export {
+  n as exhaustiveCheck
+};

package/dist/common/format.d.ts

@@ -0,0 +1,11 @@
+export declare const formatSiUnit: (value: number, minBase1000?: number, unit?: string) => string;
+export declare function formatPower(value: number, minBase1000?: number): string;
+export declare function formatEnergy(value: number, minBase1000?: number): string;
+export declare function formatMoney(value: number, precision?: number): string;
+export declare function formatDb(value: number): string;
+export declare const formatSiBaseTenUnit: (value: number, minBase1000?: number, unit?: string) => string;
+/**
+ * Formats decisecond count into HH:MM:SS display by default
+ * "short" format does not pad and adds hms suffixes
+ */
+export declare const formatTime: (val: number, formatType?: "short" | "default") => string;

package/dist/common/format.js

@@ -0,0 +1,114 @@
+const d = [
+  "f",
+  // femto
+  "p",
+  // pico
+  "n",
+  // nano
+  "μ",
+  // micro
+  "m",
+  // milli
+  // NOTE: This is a space for a reason. When we right align si numbers,
+  // in monospace mode, we want to units and numbers stay in their respective
+  // columns. If rendering in HTML mode, this space will collapse into
+  // a single space anyway.
+  " ",
+  // base
+  "k",
+  // kilo
+  "M",
+  // mega
+  "G",
+  // giga
+  "T",
+  // tera
+  "P",
+  // peta
+  "E",
+  // exa
+  "Z",
+  // zetta
+  "Y",
+  // yotta
+  "R",
+  // ronna
+  "Q",
+  // quecca
+  "F",
+  "N",
+  "H"
+], l = d.indexOf(" "), m = (t, n = -l, s = "") => {
+  if (!isFinite(t))
+    return t.toString();
+  const o = Math.floor(Math.log10(Math.abs(t))), r = Math.max(n * 3, o), e = Math.floor(r / 3), i = d[Math.min(e + l, d.length - 1)];
+  let a = (t / Math.pow(1e3, e)).toFixed(2);
+  return a.endsWith(".00") ? a = a.slice(0, -3) : a.endsWith(".0") && (a = a.slice(0, -2)), `${a} ${i.trim()}${s}`.trim();
+};
+function S(t, n = 0) {
+  return m(t, n, "W");
+}
+function $(t, n = 0) {
+  return m(t, n, "J");
+}
+function b(t, n = 0) {
+  if (!Number.isFinite(t))
+    return String(t);
+  const s = Number(t.toFixed(n)), o = s < 0, e = Math.abs(s).toString().split(".");
+  e[0] = e[0].replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+  const i = e.join(".");
+  return o ? `-${i}` : i;
+}
+function g(t) {
+  const n = 20 * Math.log10(t), s = n >= 0 ? "+" : "-";
+  let o = Math.abs(n);
+  return o === 1 / 0 ? o = "Inf" : o = o.toFixed(2), `${s}${o} dB`;
+}
+const M = [
+  "",
+  "· 10³",
+  // kilo
+  "· 10⁶",
+  // mega
+  "· 10⁹",
+  // giga
+  "· 10¹²",
+  // tera
+  "· 10¹⁵",
+  // peta
+  "· 10¹⁸",
+  // exa
+  "· 10²¹",
+  // zetta
+  "· 10²⁴",
+  // yotta
+  "· 10²⁷",
+  // ronna
+  "· 10³⁰",
+  // quecca
+  "· 10³³",
+  "· 10³⁶",
+  "· 10³⁹"
+], p = (t, n = 0, s = "") => {
+  if (!isFinite(t))
+    return "NaN";
+  const o = Math.floor(Math.log10(t)), r = Math.max(n * 3, o), e = Math.floor(r / 3), i = M[e], c = t / Math.pow(1e3, e), a = Math.max(0, 2 - r % 3);
+  return `${c.toFixed(a)} ${i} ${s}`.trim();
+}, F = (t, n = "default") => {
+  const s = Math.floor(t / 10), o = Math.floor(s / 3600), r = Math.floor(s % 3600 / 60), e = s % 60;
+  if (n === "short") {
+    const f = o > 0 ? `${o}h` : "", u = r > 0 ? `${r}m` : "", h = e > 0 ? `${e}s` : "";
+    return `${f}${u}${h}`;
+  }
+  const i = String(o).padStart(2, "0"), c = String(r).padStart(2, "0"), a = String(e).padStart(2, "0");
+  return `${i}:${c}:${a}`;
+};
+export {
+  g as formatDb,
+  $ as formatEnergy,
+  b as formatMoney,
+  S as formatPower,
+  p as formatSiBaseTenUnit,
+  m as formatSiUnit,
+  F as formatTime
+};

package/{lib/common/fp.ts → dist/common/fp.d.ts}

@@ -1,5 +1,4 @@
 type Func = (...args: any[]) => any;
-
 /**
  * Creates a function that returns the result of invoking the given
  * functions, where each successive invocation is supplied the return
@@ -15,18 +14,5 @@ type Func = (...args: any[]) => any;
  * const composedFunction2 = flow([add2, multiplyBy3], subtract5); // ((4 + 2) * 3) - 5 = 13
  *
  */
-export const flow =
-  (...funcs: Array<Func | Func[]>) =>
-  (input: any, ...rest: any[]): any => {
-    let output = input;
-
-    for (const func of funcs) {
-      // Recurse into the array of functions
-      if (Array.isArray(func)) {
-        output = flow(...func)(output, ...rest);
-      } else if (func) {
-        output = func(output, ...rest);
-      }
-    }
-    return output;
-  };
+export declare const flow: (...funcs: Array<Func | Func[]>) => (input: any, ...rest: any[]) => any;
+export {};

package/dist/common/fp.js

@@ -0,0 +1,9 @@
+const n = (...t) => (e, ...f) => {
+  let o = e;
+  for (const r of t)
+    Array.isArray(r) ? o = n(...r)(o, ...f) : r && (o = r(o, ...f));
+  return o;
+};
+export {
+  n as flow
+};

package/dist/common/hotkeys.d.ts

@@ -0,0 +1,25 @@
+import { KeyEvent } from './events';
+
+/**
+ * Acquires a lock on the hotkey, which prevents it from being
+ * passed through to BYOND.
+ */
+export declare function acquireHotKey(keyCode: number): void;
+/**
+ * Makes the hotkey available to BYOND again.
+ */
+export declare function releaseHotKey(keyCode: number): void;
+export declare function releaseHeldKeys(): void;
+export declare function setupHotKeys(): void;
+/**
+ * Registers for any key events, such as key down or key up.
+ * This should be preferred over directly connecting to keydown/keyup
+ * as it lets tgui prevent the key from reaching BYOND.
+ *
+ * If using in a component, prefer KeyListener, which automatically handles
+ * stopping listening when unmounting.
+ *
+ * @param callback The function to call whenever a key event occurs
+ * @returns A callback to stop listening
+ */
+export declare function listenForKeyEvents(callback: (key: KeyEvent) => void): () => void;