tgui-core 1.1.11 → 1.1.13

package/dist/common/redux.js

@@ -0,0 +1,72 @@
+function f(n, i) {
+  if (i)
+    return i(f)(n);
+  let t;
+  const r = [], e = () => t;
+  function c(s) {
+    r.push(s);
+  }
+  function a(s) {
+    t = n(t, s);
+    for (let o = 0; o < r.length; o++)
+      r[o]();
+  }
+  return a({ type: "@@INIT" }), {
+    dispatch: a,
+    subscribe: c,
+    getState: e
+  };
+}
+function l(...n) {
+  return (i) => (t, ...r) => {
+    const e = i(t, ...r);
+    let c = () => {
+      throw new Error(
+        "Dispatching while constructing your middleware is not allowed."
+      );
+    };
+    const a = {
+      getState: e.getState,
+      dispatch: (o, ...u) => c(o, ...u)
+    };
+    return c = n.map((o) => o(a)).reduceRight(
+      (o, u) => u(o),
+      e.dispatch
+    ), {
+      ...e,
+      dispatch: c
+    };
+  };
+}
+function d(n) {
+  const i = Object.keys(n);
+  return (t = {}, r) => {
+    const e = { ...t };
+    let c = !1;
+    for (const a of i) {
+      const s = n[a], o = t[a], u = s(o, r);
+      o !== u && (c = !0, e[a] = u);
+    }
+    return c ? e : t;
+  };
+}
+function h(n, i) {
+  function t(...r) {
+    let e = { type: n };
+    if (i) {
+      const c = i(...r);
+      if (!c)
+        throw new Error("prepare function did not return an object");
+      e = { ...e, ...c };
+    } else
+      e.payload = r[0];
+    return e;
+  }
+  return t.toString = () => n, t.type = n, t.match = (r) => r.type === n, t;
+}
+export {
+  l as applyMiddleware,
+  d as combineReducers,
+  h as createAction,
+  f as createStore
+};

package/dist/common/storage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser-agnostic abstraction of key-value web storage.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+export declare const IMPL_MEMORY = 0;
+export declare const IMPL_LOCAL_STORAGE = 1;
+export declare const IMPL_INDEXED_DB = 2;
+/**
+ * Web Storage Proxy object, which selects the best backend available
+ * depending on the environment.
+ */
+declare class StorageProxy {
+    backendPromise: Promise<any>;
+    constructor();
+    get(key: any): Promise<any>;
+    set(key: any, value: any): Promise<any>;
+    remove(key: any): Promise<any>;
+    clear(): Promise<any>;
+}
+export declare const storage: StorageProxy;
+export {};

package/dist/common/storage.js

@@ -0,0 +1,133 @@
+var l = Object.defineProperty;
+var D = (r, e, t) => e in r ? l(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var s = (r, e, t) => D(r, typeof e != "symbol" ? e + "" : e, t);
+/**
+ * Browser-agnostic abstraction of key-value web storage.
+ *
+ * @file
+ * @copyright 2020 Aleksej Komarov
+ * @license MIT
+ */
+const h = 0, P = 1, B = 2;
+const w = "tgui", a = "storage-v1", m = "readonly", i = "readwrite", d = (r) => () => {
+  try {
+    return !!r();
+  } catch {
+    return !1;
+  }
+}, I = d(
+  () => window.localStorage && window.localStorage.getItem
+), E = d(
+  () => (window.indexedDB || window.msIndexedDB) && (window.IDBTransaction || window.msIDBTransaction)
+);
+class g {
+  constructor() {
+    s(this, "impl", 0);
+    s(this, "store", {});
+    this.impl = 0, this.store = {};
+  }
+  get(e) {
+    return this.store[e];
+  }
+  set(e, t) {
+    this.store[e] = t;
+  }
+  remove(e) {
+    this.store[e] = void 0;
+  }
+  clear() {
+    this.store = {};
+  }
+}
+class u {
+  constructor() {
+    s(this, "impl", 1);
+    this.impl = 1;
+  }
+  get(e) {
+    const t = localStorage.getItem(e);
+    if (typeof t == "string")
+      return JSON.parse(t);
+  }
+  set(e, t) {
+    localStorage.setItem(e, JSON.stringify(t));
+  }
+  remove(e) {
+    localStorage.removeItem(e);
+  }
+  clear() {
+    localStorage.clear();
+  }
+}
+class _ {
+  constructor() {
+    s(this, "impl", 2);
+    s(this, "dbPromise");
+    this.impl = 2, this.dbPromise = new Promise((e, t) => {
+      const o = (window.indexedDB || window.msIndexedDB).open(w, 1);
+      o.onupgradeneeded = () => {
+        try {
+          o.result.createObjectStore(a);
+        } catch {
+          t(new Error("Failed to upgrade IDB: " + o.error));
+        }
+      }, o.onsuccess = () => e(o.result), o.onerror = () => {
+        t(new Error("Failed to open IDB: " + o.error));
+      };
+    });
+  }
+  getStore(e) {
+    return this.dbPromise.then(
+      (t) => t.transaction(a, e).objectStore(a)
+    );
+  }
+  async get(e) {
+    const t = await this.getStore(m);
+    return new Promise((c, o) => {
+      const n = t.get(e);
+      n.onsuccess = () => c(n.result), n.onerror = () => o(n.error);
+    });
+  }
+  async set(e, t) {
+    t === null && (t = void 0), (await this.getStore(i)).put(t, e);
+  }
+  async remove(e) {
+    (await this.getStore(i)).delete(e);
+  }
+  async clear() {
+    (await this.getStore(i)).clear();
+  }
+}
+class S {
+  constructor() {
+    s(this, "backendPromise");
+    this.backendPromise = (async () => {
+      if (E())
+        try {
+          const e = new _();
+          return await e.dbPromise, e;
+        } catch {
+        }
+      return I() ? new u() : new g();
+    })();
+  }
+  async get(e) {
+    return (await this.backendPromise).get(e);
+  }
+  async set(e, t) {
+    return (await this.backendPromise).set(e, t);
+  }
+  async remove(e) {
+    return (await this.backendPromise).remove(e);
+  }
+  async clear() {
+    return (await this.backendPromise).clear();
+  }
+}
+const k = new S();
+export {
+  B as IMPL_INDEXED_DB,
+  P as IMPL_LOCAL_STORAGE,
+  h as IMPL_MEMORY,
+  k as storage
+};

package/dist/common/string.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Creates a search terms matcher. Returns true if given string matches the search text.
+ *
+ * @example
+ * ```tsx
+ * type Thing = { id: string; name: string };
+ *
+ * const objects = [
+ *   { id: '123', name: 'Test' },
+ *   { id: '456', name: 'Test' },
+ * ];
+ *
+ * const search = createSearch('123', (obj: Thing) => obj.id);
+ *
+ * objects.filter(search); // returns [{ id: '123', name: 'Test' }]
+ * ```
+ */
+export declare function createSearch<TObj>(searchText: string, stringifier?: (obj: TObj) => string): (obj: TObj) => boolean;
+/**
+ * Capitalizes a word and lowercases the rest.
+ *
+ * @example
+ * ```tsx
+ * capitalize('heLLo') // Hello
+ * ```
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Similar to capitalize, this takes a string and replaces all first letters
+ * of any words.
+ *
+ * @example
+ * ```tsx
+ * capitalizeAll('heLLo woRLd') // 'HeLLo WoRLd'
+ * ```
+ */
+export declare function capitalizeAll(str: string): string;
+/**
+ * Capitalizes only the first letter of the str, leaving others untouched.
+ *
+ * @example
+ * ```tsx
+ * capitalizeFirst('heLLo woRLd') // 'HeLLo woRLd'
+ * ```
+ */
+export declare function capitalizeFirst(str: string): string;
+/**
+ * Converts a string to title case.
+ *
+ * @example
+ * ```tsx
+ * toTitleCase('a tale of two cities') // 'A Tale of Two Cities'
+ * ```
+ */
+export declare function toTitleCase(str: string): string;
+/**
+ * Decodes HTML entities and removes unnecessary HTML tags.
+ *
+ * @example
+ * ```tsx
+ * decodeHtmlEntities('&amp;') // returns '&'
+ * decodeHtmlEntities('&lt;') // returns '<'
+ * ```
+ */
+export declare function decodeHtmlEntities(str: string): string;

package/dist/common/string.js

@@ -0,0 +1,83 @@
+function p(e, t = (r) => JSON.stringify(r)) {
+  const r = e.toLowerCase().trim();
+  return (n) => {
+    if (!r)
+      return !0;
+    const o = t(n);
+    return o ? o.toLowerCase().includes(r) : !1;
+  };
+}
+function a(e) {
+  return e.charAt(0).toUpperCase() + e.slice(1).toLowerCase();
+}
+function u(e) {
+  return e.replace(/(^\w{1})|(\s+\w{1})/g, (t) => t.toUpperCase());
+}
+function l(e) {
+  return e.replace(/^\w/, (t) => t.toUpperCase());
+}
+const c = ["Id", "Tv"], s = [
+  "A",
+  "An",
+  "And",
+  "As",
+  "At",
+  "But",
+  "By",
+  "For",
+  "For",
+  "From",
+  "In",
+  "Into",
+  "Near",
+  "Nor",
+  "Of",
+  "On",
+  "Onto",
+  "Or",
+  "The",
+  "To",
+  "With"
+];
+function f(e) {
+  if (!e) return e;
+  let t = e.replace(/([^\W_]+[^\s-]*) */g, (r) => a(r));
+  for (const r of s) {
+    const n = new RegExp("\\s" + r + "\\s", "g");
+    t = t.replace(n, (o) => o.toLowerCase());
+  }
+  for (const r of c) {
+    const n = new RegExp("\\b" + r + "\\b", "g");
+    t = t.replace(n, (o) => o.toLowerCase());
+  }
+  return t;
+}
+const i = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  nbsp: " ",
+  quot: '"'
+};
+function g(e) {
+  return e && e.replace(/<br>/gi, `
+`).replace(/<\/?[a-z0-9-_]+[^>]*>/gi, "").replace(
+    /&(nbsp|amp|quot|lt|gt|apos);/g,
+    (t, r) => i[r]
+  ).replace(/&#?([0-9]+);/gi, (t, r) => {
+    const n = parseInt(r, 10);
+    return String.fromCharCode(n);
+  }).replace(/&#x?([0-9a-f]+);/gi, (t, r) => {
+    const n = parseInt(r, 16);
+    return String.fromCharCode(n);
+  });
+}
+export {
+  a as capitalize,
+  u as capitalizeAll,
+  l as capitalizeFirst,
+  p as createSearch,
+  g as decodeHtmlEntities,
+  f as toTitleCase
+};

package/dist/common/timer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns a function, that, as long as it continues to be invoked, will
+ * not be triggered. The function will be called after it stops being
+ * called for N milliseconds. If `immediate` is passed, trigger the
+ * function on the leading edge, instead of the trailing.
+ */
+export declare function debounce<F extends (...args: any[]) => any>(fn: F, time: number, immediate?: boolean): (...args: Parameters<F>) => void;
+/**
+ * Returns a function, that, when invoked, will only be triggered at most once
+ * during a given window of time.
+ */
+export declare function throttle<F extends (...args: any[]) => any>(fn: F, time: number): (...args: Parameters<F>) => void;
+/**
+ * Suspends an asynchronous function for N milliseconds.
+ *
+ * @param {number} time
+ */
+export declare function sleep(time: number): Promise<void>;

package/dist/common/timer.js

@@ -0,0 +1,28 @@
+function c(n, o, t = !1) {
+  let e;
+  return (...i) => {
+    function l() {
+      e = null, t || n(...i);
+    }
+    const u = t && !e;
+    clearTimeout(e), e = setTimeout(l, o), u && n(...i);
+  };
+}
+function r(n, o) {
+  let t, e;
+  return function i(...l) {
+    const u = Date.now();
+    e && clearTimeout(e), !t || u - t >= o ? (n(...l), t = u) : e = setTimeout(
+      () => i(...l),
+      o - (u - (t ?? 0))
+    );
+  };
+}
+function f(n) {
+  return new Promise((o) => setTimeout(o, n));
+}
+export {
+  c as debounce,
+  f as sleep,
+  r as throttle
+};

package/dist/common/type-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Helps visualize highly complex ui data on the fly.
+ * @example
+ * ```tsx
+ * const { data } = useBackend<CargoData>();
+ * logger.log(getShallowTypes(data));
+ * ```
+ */
+export declare function getShallowTypes(data: Record<string, any>): Record<string, any>;

package/dist/common/type-utils.js

@@ -0,0 +1,25 @@
+function i(n) {
+  const o = {};
+  for (const e in n)
+    if (Array.isArray(n[e])) {
+      const r = n[e];
+      if (n[e].length > 0) {
+        o[e] = r[0];
+        continue;
+      }
+      o[e] = "emptyarray";
+    } else if (typeof n[e] == "object" && n[e] !== null)
+      o[e] = "object (inspect) || Record<string, any>";
+    else if (typeof n[e] == "number") {
+      const r = Number(n[e]);
+      if (r === 1 || r === 0) {
+        o[e] = `${r}, BooleanLike?`;
+        continue;
+      }
+      o[e] = n[e];
+    }
+  return o;
+}
+export {
+  i as getShallowTypes
+};

package/dist/common/uuid.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a UUID v4 string
+ *
+ * @example
+ * ```tsx
+ * createUuid(); // 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+ * ```
+ */
+export declare function createUuid(): string;

package/dist/common/uuid.js

@@ -0,0 +1,10 @@
+function r() {
+  let x = (/* @__PURE__ */ new Date()).getTime();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+    const t = (x + Math.random() * 16) % 16 | 0;
+    return x = Math.floor(x / 16), (e === "x" ? t : t & 3 | 8).toString(16);
+  });
+}
+export {
+  r as createUuid
+};

package/dist/components/AnimatedNumber.d.ts

@@ -0,0 +1,60 @@
+import { Component } from 'react';
+
+type Props = {
+    /**
+     * If provided, a function that formats the inner string. By default,
+     * attempts to match the numeric precision of `value`.
+     */
+    format?: (value: number) => string;
+    /**
+     * If provided, the initial value displayed. By default, the same as `value`.
+     * If `initial` and `value` are different, the component immediately starts
+     * animating.
+     */
+    initial?: number;
+    /**
+     * The target value to approach.
+     */
+    value: number;
+};
+/**
+ * An animated number label. Shows a number, formatted with an optionally
+ * provided function, and animates it towards its target value.
+ */
+export declare class AnimatedNumber extends Component<Props> {
+    /**
+     * The inner `<span/>` being updated sixty times per second.
+     */
+    ref: import('react').RefObject<HTMLSpanElement>;
+    /**
+     * The interval being used to update the inner span.
+     */
+    interval?: NodeJS.Timeout;
+    /**
+     * The current value. This values approaches the target value.
+     */
+    currentValue: number;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    shouldComponentUpdate(newProps: Props): boolean;
+    /**
+     * Starts animating the inner span. If the inner span is already animating,
+     * this is a no-op.
+     */
+    startTicking(): void;
+    /**
+     * Stops animating the inner span.
+     */
+    stopTicking(): void;
+    /**
+     * Steps forward one frame.
+     */
+    tick(): void;
+    /**
+     * Gets the inner text of the span.
+     */
+    getText(): string;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/components/AnimatedNumber.js

@@ -0,0 +1,76 @@
+var f = Object.defineProperty;
+var p = (i, r, t) => r in i ? f(i, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[r] = t;
+var s = (i, r, t) => p(i, typeof r != "symbol" ? r + "" : r, t);
+import { jsx as m } from "react/jsx-runtime";
+import { Component as v, createRef as g } from "react";
+import { toFixed as d, clamp as T } from "../common/math.js";
+function o(i) {
+  return typeof i == "number" && Number.isFinite(i) && !Number.isNaN(i);
+}
+const V = 1e3 / 60, a = 0.8333, l = 1e-3;
+class S extends v {
+  constructor(t) {
+    super(t);
+    /**
+     * The inner `<span/>` being updated sixty times per second.
+     */
+    s(this, "ref", g());
+    /**
+     * The interval being used to update the inner span.
+     */
+    s(this, "interval");
+    /**
+     * The current value. This values approaches the target value.
+     */
+    s(this, "currentValue", 0);
+    const { initial: e, value: n } = t;
+    e !== void 0 && o(e) ? this.currentValue = e : o(n) && (this.currentValue = n);
+  }
+  componentDidMount() {
+    this.currentValue !== this.props.value && this.startTicking();
+  }
+  componentWillUnmount() {
+    this.stopTicking();
+  }
+  shouldComponentUpdate(t) {
+    return t.value !== this.props.value && this.startTicking(), !1;
+  }
+  /**
+   * Starts animating the inner span. If the inner span is already animating,
+   * this is a no-op.
+   */
+  startTicking() {
+    this.interval === void 0 && (this.interval = setInterval(() => this.tick(), V));
+  }
+  /**
+   * Stops animating the inner span.
+   */
+  stopTicking() {
+    this.interval !== void 0 && (clearInterval(this.interval), this.interval = void 0);
+  }
+  /**
+   * Steps forward one frame.
+   */
+  tick() {
+    const { currentValue: t } = this, { value: e } = this.props;
+    o(e) ? this.currentValue = t * a + e * (1 - a) : this.stopTicking(), Math.abs(e - this.currentValue) < Math.max(l, l * e) && (this.currentValue = e, this.stopTicking()), this.ref.current && (this.ref.current.textContent = this.getText());
+  }
+  /**
+   * Gets the inner text of the span.
+   */
+  getText() {
+    const { props: t, currentValue: e } = this, { format: n, value: u } = t;
+    if (!o(u))
+      return String(u);
+    if (n)
+      return n(this.currentValue);
+    const c = String(u).split(".")[1], h = c ? c.length : 0;
+    return d(e, T(h, 0, 8));
+  }
+  render() {
+    return /* @__PURE__ */ m("span", { ref: this.ref, children: this.getText() });
+  }
+}
+export {
+  S as AnimatedNumber
+};

package/dist/components/Autofocus.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+
+/** Used to force the window to steal focus on load. Children optional */
+export declare function Autofocus(props: PropsWithChildren): import("react/jsx-runtime").JSX.Element;

package/dist/components/Autofocus.js

@@ -0,0 +1,17 @@
+import { jsx as n } from "react/jsx-runtime";
+import { useRef as c, useEffect as f } from "react";
+function m(r) {
+  const { children: o } = r, t = c(null);
+  return f(() => {
+    const u = setTimeout(() => {
+      var e;
+      (e = t.current) == null || e.focus();
+    }, 1);
+    return () => {
+      clearTimeout(u);
+    };
+  }, []), /* @__PURE__ */ n("div", { ref: t, tabIndex: -1, children: o });
+}
+export {
+  m as Autofocus
+};

package/dist/components/Blink.d.ts

@@ -0,0 +1,26 @@
+import { Component, PropsWithChildren } from 'react';
+
+type Props = Partial<{
+    /**
+     * The interval between blinks, in milliseconds.
+     */
+    interval: number;
+    /**
+     * The time to wait before blinking again, in milliseconds.
+     */
+    time: number;
+}> & PropsWithChildren;
+type State = {
+    hidden: boolean;
+};
+export declare class Blink extends Component<Props, State> {
+    interval: NodeJS.Timeout;
+    timer: NodeJS.Timeout;
+    constructor(props: any);
+    createTimer(): void;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};