tgui-core 1.1.11 → 1.1.13

package/dist/common/hotkeys.js

@@ -0,0 +1,112 @@
+import { globalEvents as l } from "./events.js";
+import { KEY_ESCAPE as K, KEY_ENTER as E, KEY_SPACE as p, KEY_TAB as h, KEY_CTRL as d, KEY_SHIFT as g, KEY_UP as S, KEY_DOWN as Y, KEY_LEFT as _, KEY_RIGHT as b, KEY_F5 as B } from "./keycodes.js";
+const m = {}, c = [
+  K,
+  E,
+  p,
+  h,
+  d,
+  g,
+  S,
+  Y,
+  _,
+  b,
+  B
+], o = {}, u = [];
+function w(t) {
+  if (t === 16) return "Shift";
+  if (t === 17) return "Ctrl";
+  if (t === 18) return "Alt";
+  if (t === 33) return "Northeast";
+  if (t === 34) return "Southeast";
+  if (t === 35) return "Southwest";
+  if (t === 36) return "Northwest";
+  if (t === 37) return "West";
+  if (t === 38) return "North";
+  if (t === 39) return "East";
+  if (t === 40) return "South";
+  if (t === 45) return "Insert";
+  if (t === 46) return "Delete";
+  if (t >= 48 && t <= 57 || t >= 65 && t <= 90)
+    return String.fromCharCode(t);
+  if (t >= 96 && t <= 105)
+    return "Numpad" + (t - 96);
+  if (t >= 112 && t <= 123)
+    return "F" + (t - 111);
+  if (t === 188) return ",";
+  if (t === 189) return "-";
+  if (t === 190) return ".";
+}
+function F(t) {
+  const n = String(t);
+  if (n === "Ctrl+F5" || n === "Ctrl+R") {
+    location.reload();
+    return;
+  }
+  if (n === "Ctrl+F" || t.event.defaultPrevented || t.isModifierKey() || c.includes(t.code))
+    return;
+  const e = w(t.code);
+  if (!e)
+    return;
+  const f = m[e];
+  if (f)
+    return Byond.command(f);
+  if (t.isDown() && !o[e]) {
+    o[e] = !0;
+    const r = `KeyDown "${e}"`;
+    return Byond.command(r);
+  }
+  if (t.isUp() && o[e]) {
+    o[e] = !1;
+    const r = `KeyUp "${e}"`;
+    return Byond.command(r);
+  }
+}
+function O(t) {
+  c.push(t);
+}
+function P(t) {
+  const n = c.indexOf(t);
+  n >= 0 && c.splice(n, 1);
+}
+function N() {
+  for (const t of Object.keys(o))
+    o[t] && (o[t] = !1, Byond.command(`KeyUp "${t}"`));
+}
+function R() {
+  Byond.winget("default.*").then((t) => {
+    const n = {};
+    for (const r of Object.keys(t)) {
+      const s = r.split("."), i = s[1], a = s[2];
+      i && a && (n[i] || (n[i] = {}), n[i][a] = t[r]);
+    }
+    const e = /\\"/g;
+    function f(r) {
+      return r.substring(1, r.length - 1).replace(e, '"');
+    }
+    for (const r of Object.keys(n)) {
+      const s = n[r], i = f(s.name);
+      m[i] = f(s.command);
+    }
+  }), l.on("window-blur", () => {
+    N();
+  }), l.on("key", (t) => {
+    for (const n of u)
+      n(t);
+    F(t);
+  });
+}
+function v(t) {
+  u.push(t);
+  let n = !1;
+  return () => {
+    n || (n = !0, u.splice(u.indexOf(t), 1));
+  };
+}
+export {
+  O as acquireHotKey,
+  v as listenForKeyEvents,
+  N as releaseHeldKeys,
+  P as releaseHotKey,
+  R as setupHotKeys
+};

package/dist/common/http.d.ts

@@ -0,0 +1,4 @@
+/**
+ * An equivalent to `fetch`, except will automatically retry.
+ */
+export declare function fetchRetry(url: string, options?: RequestInit, retryTimer?: number): Promise<Response>;

package/dist/common/http.js

@@ -0,0 +1,10 @@
+function h(e, t, c = 1e3) {
+  return fetch(e, t).catch(() => new Promise((n) => {
+    setTimeout(() => {
+      h(e, t, c).then(n);
+    }, c);
+  }));
+}
+export {
+  h as fetchRetry
+};

package/dist/common/keycodes.d.ts

@@ -0,0 +1,85 @@
+/**
+ * All possible browser keycodes, in one file.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+export declare const KEY_BACKSPACE = 8;
+export declare const KEY_TAB = 9;
+export declare const KEY_ENTER = 13;
+export declare const KEY_SHIFT = 16;
+export declare const KEY_CTRL = 17;
+export declare const KEY_ALT = 18;
+export declare const KEY_PAUSE = 19;
+export declare const KEY_CAPSLOCK = 20;
+export declare const KEY_ESCAPE = 27;
+export declare const KEY_SPACE = 32;
+export declare const KEY_PAGEUP = 33;
+export declare const KEY_PAGEDOWN = 34;
+export declare const KEY_END = 35;
+export declare const KEY_HOME = 36;
+export declare const KEY_LEFT = 37;
+export declare const KEY_UP = 38;
+export declare const KEY_RIGHT = 39;
+export declare const KEY_DOWN = 40;
+export declare const KEY_INSERT = 45;
+export declare const KEY_DELETE = 46;
+export declare const KEY_0 = 48;
+export declare const KEY_1 = 49;
+export declare const KEY_2 = 50;
+export declare const KEY_3 = 51;
+export declare const KEY_4 = 52;
+export declare const KEY_5 = 53;
+export declare const KEY_6 = 54;
+export declare const KEY_7 = 55;
+export declare const KEY_8 = 56;
+export declare const KEY_9 = 57;
+export declare const KEY_A = 65;
+export declare const KEY_B = 66;
+export declare const KEY_C = 67;
+export declare const KEY_D = 68;
+export declare const KEY_E = 69;
+export declare const KEY_F = 70;
+export declare const KEY_G = 71;
+export declare const KEY_H = 72;
+export declare const KEY_I = 73;
+export declare const KEY_J = 74;
+export declare const KEY_K = 75;
+export declare const KEY_L = 76;
+export declare const KEY_M = 77;
+export declare const KEY_N = 78;
+export declare const KEY_O = 79;
+export declare const KEY_P = 80;
+export declare const KEY_Q = 81;
+export declare const KEY_R = 82;
+export declare const KEY_S = 83;
+export declare const KEY_T = 84;
+export declare const KEY_U = 85;
+export declare const KEY_V = 86;
+export declare const KEY_W = 87;
+export declare const KEY_X = 88;
+export declare const KEY_Y = 89;
+export declare const KEY_Z = 90;
+export declare const KEY_F1 = 112;
+export declare const KEY_F2 = 113;
+export declare const KEY_F3 = 114;
+export declare const KEY_F4 = 115;
+export declare const KEY_F5 = 116;
+export declare const KEY_F6 = 117;
+export declare const KEY_F7 = 118;
+export declare const KEY_F8 = 119;
+export declare const KEY_F9 = 120;
+export declare const KEY_F10 = 121;
+export declare const KEY_F11 = 122;
+export declare const KEY_F12 = 123;
+export declare const KEY_SEMICOLON = 186;
+export declare const KEY_EQUAL = 187;
+export declare const KEY_COMMA = 188;
+export declare const KEY_MINUS = 189;
+export declare const KEY_PERIOD = 190;
+export declare const KEY_SLASH = 191;
+export declare const KEY_LEFT_BRACKET = 219;
+export declare const KEY_BACKSLASH = 220;
+export declare const KEY_RIGHT_BRACKET = 221;
+export declare const KEY_QUOTE = 222;

package/dist/common/keycodes.js

@@ -0,0 +1,88 @@
+/**
+ * All possible browser keycodes, in one file.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const E = 8, K = 9, _ = 13, o = 16, t = 17, Y = 18, c = 19, n = 20, s = 27, A = 32, F = 33, T = 34, S = 35, C = 36, L = 37, P = 38, O = 39, R = 40, I = 45, N = 46, H = 48, U = 49, B = 50, D = 51, M = 52, G = 53, Q = 54, W = 55, e = 56, p = 57, r = 65, x = 66, J = 67, V = 68, X = 69, Z = 70, a = 71, b = 72, d = 73, f = 74, g = 75, h = 76, i = 77, j = 78, k = 79, l = 80, m = 81, q = 82, u = 83, v = 84, w = 85, y = 86, z = 87, $ = 88, EE = 89, KE = 90, _E = 112, oE = 113, tE = 114, YE = 115, cE = 116, nE = 117, sE = 118, AE = 119, FE = 120, TE = 121, SE = 122, CE = 123, LE = 186, PE = 187, OE = 188, RE = 189, IE = 190, NE = 191, HE = 219, UE = 220, BE = 221, DE = 222;
+export {
+  H as KEY_0,
+  U as KEY_1,
+  B as KEY_2,
+  D as KEY_3,
+  M as KEY_4,
+  G as KEY_5,
+  Q as KEY_6,
+  W as KEY_7,
+  e as KEY_8,
+  p as KEY_9,
+  r as KEY_A,
+  Y as KEY_ALT,
+  x as KEY_B,
+  UE as KEY_BACKSLASH,
+  E as KEY_BACKSPACE,
+  J as KEY_C,
+  n as KEY_CAPSLOCK,
+  OE as KEY_COMMA,
+  t as KEY_CTRL,
+  V as KEY_D,
+  N as KEY_DELETE,
+  R as KEY_DOWN,
+  X as KEY_E,
+  S as KEY_END,
+  _ as KEY_ENTER,
+  PE as KEY_EQUAL,
+  s as KEY_ESCAPE,
+  Z as KEY_F,
+  _E as KEY_F1,
+  TE as KEY_F10,
+  SE as KEY_F11,
+  CE as KEY_F12,
+  oE as KEY_F2,
+  tE as KEY_F3,
+  YE as KEY_F4,
+  cE as KEY_F5,
+  nE as KEY_F6,
+  sE as KEY_F7,
+  AE as KEY_F8,
+  FE as KEY_F9,
+  a as KEY_G,
+  b as KEY_H,
+  C as KEY_HOME,
+  d as KEY_I,
+  I as KEY_INSERT,
+  f as KEY_J,
+  g as KEY_K,
+  h as KEY_L,
+  L as KEY_LEFT,
+  HE as KEY_LEFT_BRACKET,
+  i as KEY_M,
+  RE as KEY_MINUS,
+  j as KEY_N,
+  k as KEY_O,
+  l as KEY_P,
+  T as KEY_PAGEDOWN,
+  F as KEY_PAGEUP,
+  c as KEY_PAUSE,
+  IE as KEY_PERIOD,
+  m as KEY_Q,
+  DE as KEY_QUOTE,
+  q as KEY_R,
+  O as KEY_RIGHT,
+  BE as KEY_RIGHT_BRACKET,
+  u as KEY_S,
+  LE as KEY_SEMICOLON,
+  o as KEY_SHIFT,
+  NE as KEY_SLASH,
+  A as KEY_SPACE,
+  v as KEY_T,
+  K as KEY_TAB,
+  w as KEY_U,
+  P as KEY_UP,
+  y as KEY_V,
+  z as KEY_W,
+  $ as KEY_X,
+  EE as KEY_Y,
+  KE as KEY_Z
+};

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

@@ -20,28 +20,27 @@
  *
  *
  */
-export enum KEY {
-  Alt = 'Alt',
-  Backspace = 'Backspace',
-  Control = 'Control',
-  Delete = 'Delete',
-  Down = 'ArrowDown',
-  End = 'End',
-  Enter = 'Enter',
-  Esc = 'Esc',
-  Escape = 'Escape',
-  Home = 'Home',
-  Insert = 'Insert',
-  Left = 'ArrowLeft',
-  PageDown = 'PageDown',
-  PageUp = 'PageUp',
-  Right = 'ArrowRight',
-  Shift = 'Shift',
-  Space = ' ',
-  Tab = 'Tab',
-  Up = 'ArrowUp',
+export declare enum KEY {
+    Alt = "Alt",
+    Backspace = "Backspace",
+    Control = "Control",
+    Delete = "Delete",
+    Down = "ArrowDown",
+    End = "End",
+    Enter = "Enter",
+    Esc = "Esc",
+    Escape = "Escape",
+    Home = "Home",
+    Insert = "Insert",
+    Left = "ArrowLeft",
+    PageDown = "PageDown",
+    PageUp = "PageUp",
+    Right = "ArrowRight",
+    Shift = "Shift",
+    Space = " ",
+    Tab = "Tab",
+    Up = "ArrowUp"
 }
-
 /**
  * ### isEscape
  *
@@ -53,6 +52,4 @@ export enum KEY {
  * @param key - the key to check, typically from event.key
  * @returns true if key is Escape or Esc, false otherwise
  */
-export function isEscape(key: string): boolean {
-  return key === KEY.Esc || key === KEY.Escape;
-}
+export declare function isEscape(key: string): boolean;

package/dist/common/keys.js

@@ -0,0 +1,8 @@
+var r = /* @__PURE__ */ ((e) => (e.Alt = "Alt", e.Backspace = "Backspace", e.Control = "Control", e.Delete = "Delete", e.Down = "ArrowDown", e.End = "End", e.Enter = "Enter", e.Esc = "Esc", e.Escape = "Escape", e.Home = "Home", e.Insert = "Insert", e.Left = "ArrowLeft", e.PageDown = "PageDown", e.PageUp = "PageUp", e.Right = "ArrowRight", e.Shift = "Shift", e.Space = " ", e.Tab = "Tab", e.Up = "ArrowUp", e))(r || {});
+function t(e) {
+  return e === "Esc" || e === "Escape";
+}
+export {
+  r as KEY,
+  t as isEscape
+};

package/dist/common/math.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Limits a number to the range between 'min' and 'max'.
+ */
+export declare function clamp(value: any, min: any, max: any): any;
+/**
+ * Limits a number between 0 and 1.
+ */
+export declare function clamp01(value: any): any;
+/**
+ * Scales a number to fit into the range between min and max.
+ */
+export declare function scale(value: any, min: any, max: any): number;
+/**
+ * Robust number rounding, similar to PHP's round() function.
+ *
+ * @url https://stackoverflow.com/questions/53450248/how-to-round-in-javascript-like-php-do/54721202#54721202
+ */
+export declare function round(num: any, dec: any): number;
+/**
+ * Returns a string representing a number in fixed point notation.
+ */
+export declare function toFixed(value: any, fractionDigits?: number): string;
+/**
+ * Checks whether a value is within the provided range.
+ *
+ * Range is an array of two numbers, for example: [0, 15].
+ */
+export declare function inRange(value: any, range: any): any;
+/**
+ * Walks over the object with ranges, comparing value against every range,
+ * and returns the key of the first matching range.
+ *
+ * Range is an array of two numbers, for example: [0, 15].
+ */
+export declare function keyOfMatchingRange(value: any, ranges: any): string | undefined;
+/**
+ * Get number of digits following the decimal point in a number
+ */
+export declare function numberOfDecimalDigits(value: any): any;

package/dist/common/math.js

@@ -0,0 +1,41 @@
+function e(t, n, r) {
+  return t < n ? n : t > r ? r : t;
+}
+function c(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function f(t, n, r) {
+  return (t - n) / (r - n);
+}
+function u(t, n) {
+  const r = t >= 0 ? 1 : -1;
+  return parseFloat(
+    (Math.round(t * Math.pow(10, n) + r * 1e-4) / Math.pow(10, n)).toFixed(n)
+  );
+}
+function s(t, n = 0) {
+  return Number(t).toFixed(Math.max(n, 0));
+}
+function i(t, n) {
+  return n && t >= n[0] && t <= n[1];
+}
+function a(t, n) {
+  for (const r of Object.keys(n)) {
+    const o = n[r];
+    if (i(t, o))
+      return r;
+  }
+}
+function h(t) {
+  return Math.floor(t) !== t && t.toString().split(".")[1].length || 0;
+}
+export {
+  e as clamp,
+  c as clamp01,
+  i as inRange,
+  a as keyOfMatchingRange,
+  h as numberOfDecimalDigits,
+  u as round,
+  f as scale,
+  s as toFixed
+};

package/dist/common/perf.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Ghetto performance measurement tools.
+ *
+ * Uses NODE_ENV to remove itself from production builds.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+/**
+ * Marks a certain spot in the code for later measurements.
+ */
+declare function mark(name: string, timestamp?: number): void;
+/**
+ * Calculates and returns the difference between two markers as a string.
+ *
+ * Use logger.log() to print the measurement.
+ */
+declare function measure(markerNameA: string, markerNameB: string): string | undefined;
+export declare const perf: {
+    mark: typeof mark;
+    measure: typeof measure;
+};
+export {};

package/dist/common/perf.js

@@ -0,0 +1,33 @@
+/**
+ * Ghetto performance measurement tools.
+ *
+ * Uses NODE_ENV to remove itself from production builds.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const i = 16.666666666666668;
+var c;
+const a = !!((c = window.performance) != null && c.now), t = {}, s = {};
+function p(o, n) {
+  process.env.NODE_ENV !== "production" && (a && !n && (t[o] = performance.now()), s[o] = n || Date.now());
+}
+function u(o, n) {
+  if (process.env.NODE_ENV === "production") return;
+  let r = t[o], e = t[n];
+  (!r || !e) && (r = s[o], e = s[n]);
+  const f = Math.abs(e - r);
+  return F(f);
+}
+function F(o) {
+  const n = o / i;
+  return o.toFixed(o < 10 ? 1 : 0) + "ms (" + n.toFixed(2) + " frames)";
+}
+const d = {
+  mark: p,
+  measure: u
+};
+export {
+  d as perf
+};

package/dist/common/random.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns random number between lowerBound exclusive and upperBound inclusive
+ */
+export declare function randomNumber(lowerBound: number, upperBound: number): number;
+/**
+ * Returns random integer between lowerBound exclusive and upperBound inclusive
+ */
+export declare function randomInteger(lowerBound: number, upperBound: number): number;
+/**
+ * Returns random array element
+ */
+export declare const randomPick: <T>(array: T[]) => T;
+/**
+ * Return 1 with probability P percent; otherwise 0
+ */
+export declare function randomProb(probability: number): boolean;

package/dist/common/random.js

@@ -0,0 +1,18 @@
+import { clamp as n } from "./math.js";
+function o(t, r) {
+  return Math.random() * (r - t) + t;
+}
+function m(t, r) {
+  return t = Math.ceil(t), r = Math.floor(r), Math.floor(Math.random() * (r - t) + t);
+}
+const h = (t) => t[Math.floor(Math.random() * t.length)];
+function c(t) {
+  const r = n(t, 0, 100) / 100;
+  return Math.random() <= r;
+}
+export {
+  m as randomInteger,
+  o as randomNumber,
+  h as randomPick,
+  c as randomProb
+};

package/dist/common/react.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helper for conditionally adding/removing classes in React
+ */
+export declare function classes(classNames: (string | BooleanLike)[]): string;
+/**
+ * Normalizes children prop, so that it is always an array of VDom
+ * elements.
+ */
+export declare function normalizeChildren<T>(children: T | T[]): T[];
+/**
+ * Shallowly checks if two objects are different.
+ * Credit: https://github.com/developit/preact-compat
+ */
+export declare function shallowDiffers(a: object, b: object): boolean;
+/**
+ * A common case in tgui, when you pass a value conditionally, these are
+ * the types that can fall through the condition.
+ */
+export type BooleanLike = number | boolean | null | undefined;
+/**
+ * A helper to determine whether the object is renderable by React.
+ */
+export declare function canRender(value: unknown): boolean;

package/dist/common/react.js

@@ -0,0 +1,30 @@
+function f(r) {
+  let n = "";
+  for (let t = 0; t < r.length; t++) {
+    const e = r[t];
+    typeof e == "string" && (n += e + " ");
+  }
+  return n;
+}
+function i(r) {
+  return Array.isArray(r) ? r.flat().filter((n) => n) : typeof r == "object" ? [r] : [];
+}
+function o(r, n) {
+  let t;
+  for (t in r)
+    if (!(t in n))
+      return !0;
+  for (t in n)
+    if (r[t] !== n[t])
+      return !0;
+  return !1;
+}
+function u(r) {
+  return r != null && typeof r != "boolean";
+}
+export {
+  u as canRender,
+  f as classes,
+  i as normalizeChildren,
+  o as shallowDiffers
+};

package/dist/common/redux.d.ts

@@ -0,0 +1,64 @@
+export type Reducer<State = any, ActionType extends Action = AnyAction> = (state: State | undefined, action: ActionType) => State;
+export type Store<State = any, ActionType extends Action = AnyAction> = {
+    dispatch: Dispatch<ActionType>;
+    getState: () => State;
+    subscribe: (listener: () => void) => void;
+};
+type MiddlewareAPI<State = any, ActionType extends Action = AnyAction> = {
+    dispatch: Dispatch<ActionType>;
+    getState: () => State;
+};
+export type Middleware = <State = any, ActionType extends Action = AnyAction>(storeApi: MiddlewareAPI<State, ActionType>) => (next: Dispatch<ActionType>) => Dispatch<ActionType>;
+export type Action<TType = any> = {
+    type: TType;
+};
+export type AnyAction = Action & {
+    [extraProps: string]: any;
+};
+export type Dispatch<ActionType extends Action = AnyAction> = (action: ActionType) => void;
+type StoreEnhancer = (createStoreFunction: Function) => Function;
+type PreparedAction = {
+    meta?: any;
+    payload?: any;
+};
+/**
+ * Creates a Redux store.
+ */
+export declare function createStore<State, ActionType extends Action = AnyAction>(reducer: Reducer<State, ActionType>, enhancer?: StoreEnhancer): Store<State, ActionType>;
+/**
+ * Creates a store enhancer which applies middleware to all dispatched
+ * actions.
+ */
+export declare function applyMiddleware(...middlewares: Middleware[]): StoreEnhancer;
+/**
+ * Combines reducers by running them in their own object namespaces as
+ * defined in reducersObj paramter.
+ *
+ * Main difference from redux/combineReducers is that it preserves keys
+ * in the state that are not present in the reducers object. This function
+ * is also more flexible than the redux counterpart.
+ */
+export declare function combineReducers(reducersObj: Record<string, Reducer>): Reducer;
+/**
+ * A utility function to create an action creator for the given action
+ * type string. The action creator accepts a single argument, which will
+ * be included in the action object as a field called payload. The action
+ * creator function will also have its toString() overriden so that it
+ * returns the action type, allowing it to be used in reducer logic that
+ * is looking for that action type.
+ *
+ * @param {string} type The action type to use for created actions.
+ * @param {any} prepare (optional) a method that takes any number of arguments
+ * and returns { payload } or { payload, meta }. If this is given, the
+ * resulting action creator will pass it's arguments to this method to
+ * calculate payload & meta.
+ *
+ * @public
+ */
+export declare function createAction<TAction extends string>(type: TAction, prepare?: (...args: any[]) => PreparedAction): {
+    (...args: any[]): Action<TAction> & PreparedAction;
+    toString(): TAction;
+    type: TAction;
+    match(action: any): boolean;
+};
+export {};