tgui-core 1.0.6 → 1.0.7

package/README.md

@@ -2,9 +2,9 @@
 
 A collection of utilities and components for the [tgui](https://github.com/tgstation/tgstation) framework.
 
-You can view the code on [GitHub](https://github.com/jlsnow301/tgui-core).
+This package was built to help the various downstream SS13 servers stay up to date with TGUI without having to keep a local version of each file.
 
-This package was built to help the various downstream SS13 servers of SS13 update TGUI to the latest version.
+You can view the code on [GitHub](https://github.com/jlsnow301/tgui-core).
 
 ## Installation
 

package/dist/assets.d.ts

@@ -0,0 +1,4 @@
+import { Middleware } from './common/redux';
+
+export declare const resolveAsset: (name: string) => string;
+export declare const assetMiddleware: Middleware;

package/dist/assets.js

@@ -0,0 +1,26 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const l = [/v4shim/i], d = {}, r = (t) => d[t] || t, f = (t) => (p) => (n) => {
+  const { type: i, payload: e } = n;
+  if (i === "asset/stylesheet") {
+    Byond.loadCss(e);
+    return;
+  }
+  if (i === "asset/mappings") {
+    for (const s of Object.keys(e)) {
+      if (l.some((c) => c.test(s)))
+        continue;
+      const o = e[s], a = s.split(".").pop();
+      d[s] = o, a === "css" && Byond.loadCss(o), a === "js" && Byond.loadJs(o);
+    }
+    return;
+  }
+  p(n);
+};
+export {
+  f as assetMiddleware,
+  r as resolveAsset
+};

package/dist/common/collections.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+/**
+ * Iterates over elements of collection, returning an array of all elements
+ * iteratee returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * If collection is 'null' or 'undefined', it will be returned "as is"
+ * without emitting any errors (which can be useful in some cases).
+ */
+export declare const filter: <T>(collection: T[], iterateeFn: (input: T, index: number, collection: T[]) => boolean) => T[];
+type MapFunction = {
+    <T, U>(collection: T[], iterateeFn: (value: T, index: number, collection: T[]) => U): U[];
+    <T, U, K extends string | number>(collection: Record<K, T>, iterateeFn: (value: T, index: K, collection: Record<K, T>) => U): U[];
+};
+/**
+ * Creates an array of values by running each element in collection
+ * thru an iteratee function. The iteratee is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * If collection is 'null' or 'undefined', it will be returned "as is"
+ * without emitting any errors (which can be useful in some cases).
+ */
+export declare const map: MapFunction;
+/**
+ * Creates an array of elements, sorted in ascending order by the results
+ * of running each element in a collection thru each iteratee.
+ *
+ * Iteratees are called with one argument (value).
+ */
+export declare const sortBy: <T>(array: T[], ...iterateeFns: ((input: T) => unknown)[]) => T[];
+export declare const sort: <T>(array: T[]) => T[];
+/**
+ * Returns a range of numbers from start to end, exclusively.
+ * For example, range(0, 5) will return [0, 1, 2, 3, 4].
+ */
+export declare const range: (start: number, end: number) => number[];
+type ReduceFunction = {
+    <T, U>(array: T[], reducerFn: (accumulator: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    <T>(array: T[], reducerFn: (accumulator: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+};
+/**
+ * A fast implementation of reduce.
+ */
+export declare const reduce: ReduceFunction;
+/**
+ * Creates a duplicate-free version of an array, using SameValueZero for
+ * equality comparisons, in which only the first occurrence of each element
+ * is kept. The order of result values is determined by the order they occur
+ * in the array.
+ *
+ * It accepts iteratee which is invoked for each element in array to generate
+ * the criterion by which uniqueness is computed. The order of result values
+ * is determined by the order they occur in the array. The iteratee is
+ * invoked with one argument: value.
+ */
+export declare const uniqBy: <T extends unknown>(array: T[], iterateeFn?: (value: T) => unknown) => T[];
+export declare const uniq: <T>(array: T[]) => T[];
+type Zip<T extends unknown[][]> = {
+    [I in keyof T]: T[I] extends (infer U)[] ? U : never;
+}[];
+/**
+ * Creates an array of grouped elements, the first of which contains
+ * the first elements of the given arrays, the second of which contains
+ * the second elements of the given arrays, and so on.
+ */
+export declare const zip: <T extends unknown[][]>(...arrays: T) => Zip<T>;
+export declare const binaryInsertWith: <T, U = unknown>(collection: readonly T[], value: T, getKey: (value: T) => U) => T[];
+/**
+ * This method takes a collection of items and a number, returning a collection
+ * of collections, where the maximum amount of items in each is that second arg
+ */
+export declare const paginate: <T>(collection: T[], maxPerPage: number) => T[][];
+export declare const deepMerge: (...objects: any[]) => any;
+export {};

package/dist/common/collections.js

@@ -0,0 +1,139 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const y = (t, n) => {
+  if (t == null)
+    return t;
+  if (Array.isArray(t)) {
+    const s = [];
+    for (let e = 0; e < t.length; e++) {
+      const r = t[e];
+      n(r, e, t) && s.push(r);
+    }
+    return s;
+  }
+  throw new Error(`filter() can't iterate on type ${typeof t}`);
+}, d = (t, n) => {
+  if (t == null)
+    return t;
+  if (Array.isArray(t)) {
+    const s = [];
+    for (let e = 0; e < t.length; e++)
+      s.push(n(t[e], e, t));
+    return s;
+  }
+  if (typeof t == "object") {
+    const s = [];
+    for (let e in t)
+      Object.prototype.hasOwnProperty.call(t, e) && s.push(n(t[e], e, t));
+    return s;
+  }
+  throw new Error(`map() can't iterate on type ${typeof t}`);
+}, p = (t, n) => {
+  const s = t.criteria, e = n.criteria, r = s.length;
+  for (let u = 0; u < r; u++) {
+    const i = s[u], f = e[u];
+    if (i < f)
+      return -1;
+    if (i > f)
+      return 1;
+  }
+  return 0;
+}, l = (t, ...n) => {
+  if (!Array.isArray(t))
+    return t;
+  let s = t.length, e = [];
+  for (let u = 0; u < s; u++) {
+    const i = t[u];
+    e.push({
+      criteria: n.map((f) => f(i)),
+      value: i
+    });
+  }
+  e.sort(p);
+  const r = [];
+  for (; s--; )
+    r[s] = e[s].value;
+  return r;
+}, A = (t) => l(t), m = (t, n) => new Array(n - t).fill(null).map((s, e) => e + t), w = (t, n, s) => {
+  const e = t.length;
+  let r, u;
+  for (s === void 0 ? (r = 1, u = t[0]) : (r = 0, u = s); r < e; r++)
+    u = n(u, t[r], r, t);
+  return u;
+}, c = (t, n) => {
+  const { length: s } = t, e = [], r = n ? [] : e;
+  let u = -1;
+  t:
+    for (; ++u < s; ) {
+      let i = t[u];
+      const f = n ? n(i) : i;
+      if (f === f) {
+        let o = r.length;
+        for (; o--; )
+          if (r[o] === f)
+            continue t;
+        n && r.push(f), e.push(i);
+      } else
+        r.includes(f) || (r !== e && r.push(f), e.push(i));
+    }
+  return e;
+}, b = (t) => c(t), v = (...t) => {
+  if (t.length === 0)
+    return [];
+  const n = t.length, s = t[0].length, e = [];
+  for (let r = 0; r < s; r++) {
+    const u = [];
+    for (let i = 0; i < n; i++)
+      u.push(t[i][r]);
+    e.push(u);
+  }
+  return e;
+}, g = (t, n, s) => {
+  if (n.length === 0)
+    return 0;
+  const e = t(s);
+  let [r, u] = [0, n.length], i, f = 0;
+  for (; r < u; )
+    if (f = r + u >> 1, i = t(n[f]), i < e)
+      r = f + 1;
+    else {
+      if (i === e)
+        return f;
+      u = f;
+    }
+  return i > e ? f : f + 1;
+}, j = (t, n, s) => {
+  const e = [...t];
+  return e.splice(g(s, t, n), 0, n), e;
+}, O = (t, n) => {
+  const s = [];
+  let e = [], r = n;
+  for (const u of t)
+    e.push(u), r--, r || (r = n, s.push(e), e = []);
+  return e.length && s.push(e), s;
+}, h = (t) => typeof t == "object" && t !== null, a = (...t) => {
+  const n = {};
+  for (const s of t)
+    for (const e of Object.keys(s)) {
+      const r = n[e], u = s[e];
+      Array.isArray(r) && Array.isArray(u) ? n[e] = [...r, ...u] : h(r) && h(u) ? n[e] = a(r, u) : n[e] = u;
+    }
+  return n;
+};
+export {
+  j as binaryInsertWith,
+  a as deepMerge,
+  y as filter,
+  d as map,
+  O as paginate,
+  m as range,
+  w as reduce,
+  A as sort,
+  l as sortBy,
+  b as uniq,
+  c as uniqBy,
+  v as zip
+};

package/dist/common/color.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+export declare class Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r?: number, g?: number, b?: number, a?: number);
+    toString(): string;
+    /**  Darkens a color by a given percent. Returns a color, which can have toString called to get it's rgba() css value. */
+    darken(percent: number): Color;
+    /** Brightens a color by a given percent. Returns a color, which can have toString called to get it's rgba() css value. */
+    lighten(percent: number): Color;
+    /**
+     * Creates a color from the CSS hex color notation.
+     */
+    static fromHex(hex: string): Color;
+    /**
+     * Linear interpolation of two colors.
+     */
+    static lerp(c1: Color, c2: Color, n: number): Color;
+    /**
+     * Loops up the color in the provided list of colors
+     * with linear interpolation.
+     */
+    static lookup(value: number, colors: Color[]): Color;
+}

package/dist/common/color.js

@@ -0,0 +1,74 @@
+var b = Object.defineProperty;
+var l = (i, t, s) => t in i ? b(i, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : i[t] = s;
+var e = (i, t, s) => (l(i, typeof t != "symbol" ? t + "" : t, s), s);
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+class n {
+  constructor(t = 0, s = 0, r = 0, a = 1) {
+    e(this, "r");
+    e(this, "g");
+    e(this, "b");
+    e(this, "a");
+    this.r = t, this.g = s, this.b = r, this.a = a;
+  }
+  toString() {
+    let t = this.a;
+    return typeof t == "string" && (t = parseFloat(this.a)), isNaN(t) && (t = 1), `rgba(${this.r | 0}, ${this.g | 0}, ${this.b | 0}, ${t})`;
+  }
+  /**  Darkens a color by a given percent. Returns a color, which can have toString called to get it's rgba() css value. */
+  darken(t) {
+    return t /= 100, new n(
+      this.r - this.r * t,
+      this.g - this.g * t,
+      this.b - this.b * t,
+      this.a
+    );
+  }
+  /** Brightens a color by a given percent. Returns a color, which can have toString called to get it's rgba() css value. */
+  lighten(t) {
+    return this.darken(-t);
+  }
+  /**
+   * Creates a color from the CSS hex color notation.
+   */
+  static fromHex(t) {
+    return new n(
+      parseInt(t.slice(1, 3), 16),
+      parseInt(t.slice(3, 5), 16),
+      parseInt(t.slice(5, 7), 16)
+    );
+  }
+  /**
+   * Linear interpolation of two colors.
+   */
+  static lerp(t, s, r) {
+    return new n(
+      (s.r - t.r) * r + t.r,
+      (s.g - t.g) * r + t.g,
+      (s.b - t.b) * r + t.b,
+      (s.a - t.a) * r + t.a
+    );
+  }
+  /**
+   * Loops up the color in the provided list of colors
+   * with linear interpolation.
+   */
+  static lookup(t, s) {
+    const r = s.length;
+    if (r < 2)
+      throw new Error("Needs at least two colors!");
+    const a = t * (r - 1);
+    if (t < 1e-4)
+      return s[0];
+    if (t >= 1 - 1e-4)
+      return s[r - 1];
+    const g = a % 1, h = a | 0;
+    return this.lerp(s[h], s[h + 1], g);
+  }
+}
+export {
+  n as Color
+};

package/dist/common/events.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+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 {};

package/dist/common/events.js

@@ -0,0 +1,37 @@
+var h = Object.defineProperty;
+var c = (e, s, t) => s in e ? h(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var n = (e, s, t) => (c(e, typeof s != "symbol" ? s + "" : s, t), t);
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+class u {
+  constructor() {
+    n(this, "listeners");
+    this.listeners = {};
+  }
+  on(s, t) {
+    this.listeners[s] = this.listeners[s] || [], this.listeners[s].push(t);
+  }
+  off(s, t) {
+    const r = this.listeners[s];
+    if (!r)
+      throw new Error(`There is no listeners for "${s}"`);
+    this.listeners[s] = r.filter((i) => i !== t);
+  }
+  emit(s, ...t) {
+    const r = this.listeners[s];
+    if (r)
+      for (let i = 0, l = r.length; i < l; i += 1) {
+        const o = r[i];
+        o(...t);
+      }
+  }
+  clear() {
+    this.listeners = {};
+  }
+}
+export {
+  u as EventEmitter
+};

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

@@ -1,19 +1,17 @@
-/**
- * Throws an error such that a non-exhaustive check will error at compile time
- * when using TypeScript, rather than at runtime.
- *
- * For example:
- * enum Color { Red, Green, Blue }
- * switch (color) {
- *  case Color.Red:
- *    return "red";
- *  case Color.Green:
- *    return "green";
- *  default:
- *    // This will error at compile time that we forgot blue.
- *    exhaustiveCheck(color);
- * }
- */
-export const exhaustiveCheck = (input: never) => {
-  throw new Error(`Unhandled case: ${input}`);
-};
+/**
+ * Throws an error such that a non-exhaustive check will error at compile time
+ * when using TypeScript, rather than at runtime.
+ *
+ * For example:
+ * enum Color { Red, Green, Blue }
+ * switch (color) {
+ *  case Color.Red:
+ *    return "red";
+ *  case Color.Green:
+ *    return "green";
+ *  default:
+ *    // This will error at compile time that we forgot blue.
+ *    exhaustiveCheck(color);
+ * }
+ */
+export declare const exhaustiveCheck: (input: never) => never;

package/dist/common/exhaustive.js

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

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

@@ -1,38 +1,23 @@
-/**
- * @file
- * @copyright 2020 Aleksej Komarov
- * @license MIT
- */
-
-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
- * value of the previous.
- *
- * @example
- * ```tsx
- * const add2 = (x) => x + 2;
- * const multiplyBy3 = (x) => x * 3;
- * const subtract5 = (x) => x - 5;
- *
- * const composedFunction = flow(add2, multiplyBy3, subtract5); // ((4 + 2) * 3) - 5 = 13
- * 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 (let 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;
-  };
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+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
+ * value of the previous.
+ *
+ * @example
+ * ```tsx
+ * const add2 = (x) => x + 2;
+ * const multiplyBy3 = (x) => x * 3;
+ * const subtract5 = (x) => x - 5;
+ *
+ * const composedFunction = flow(add2, multiplyBy3, subtract5); // ((4 + 2) * 3) - 5 = 13
+ * const composedFunction2 = flow([add2, multiplyBy3], subtract5); // ((4 + 2) * 3) - 5 = 13
+ *
+ */
+export declare const flow: (...funcs: Array<Func | Func[]>) => (input: any, ...rest: any[]) => any;
+export {};

package/dist/common/fp.js

@@ -0,0 +1,14 @@
+/**
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const l = (...t) => (e, ...o) => {
+  let r = e;
+  for (let f of t)
+    Array.isArray(f) ? r = l(...f)(r, ...o) : f && (r = f(r, ...o));
+  return r;
+};
+export {
+  l as flow
+};

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;