@buoy-gg/shared-ui 1.7.2

package/lib/commonjs/ui/gameUI/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GAME_UI_ALERT_STATES", {
+  enumerable: true,
+  get: function () {
+    return _useGameUIAlertState.GAME_UI_ALERT_STATES;
+  }
+});
+Object.defineProperty(exports, "GameUICollapsibleSection", {
+  enumerable: true,
+  get: function () {
+    return _GameUICollapsibleSection.GameUICollapsibleSection;
+  }
+});
+Object.defineProperty(exports, "GameUICompactStats", {
+  enumerable: true,
+  get: function () {
+    return _GameUICompactStats.GameUICompactStats;
+  }
+});
+Object.defineProperty(exports, "GameUIIssuesList", {
+  enumerable: true,
+  get: function () {
+    return _GameUIIssuesList.GameUIIssuesList;
+  }
+});
+Object.defineProperty(exports, "GameUIStatusHeader", {
+  enumerable: true,
+  get: function () {
+    return _GameUIStatusHeader.GameUIStatusHeader;
+  }
+});
+Object.defineProperty(exports, "buoyColors", {
+  enumerable: true,
+  get: function () {
+    return _gameUIColors.buoyColors;
+  }
+});
+Object.defineProperty(exports, "dialColors", {
+  enumerable: true,
+  get: function () {
+    return _gameUIColors.dialColors;
+  }
+});
+Object.defineProperty(exports, "gameUIColors", {
+  enumerable: true,
+  get: function () {
+    return _gameUIColors.gameUIColors;
+  }
+});
+Object.defineProperty(exports, "macOSColors", {
+  enumerable: true,
+  get: function () {
+    return _macOSDesignSystemColors.macOSColors;
+  }
+});
+Object.defineProperty(exports, "useGameUIAlertState", {
+  enumerable: true,
+  get: function () {
+    return _useGameUIAlertState.useGameUIAlertState;
+  }
+});
+var _GameUICollapsibleSection = require("./components/GameUICollapsibleSection.js");
+var _GameUIStatusHeader = require("./components/GameUIStatusHeader.js");
+var _GameUICompactStats = require("./components/GameUICompactStats.js");
+var _GameUIIssuesList = require("./components/GameUIIssuesList.js");
+var _useGameUIAlertState = require("./hooks/useGameUIAlertState.js");
+var _gameUIColors = require("./constants/gameUIColors.js");
+var _macOSDesignSystemColors = require("./constants/macOSDesignSystemColors.js");

package/lib/commonjs/ui/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  CyberpunkSectionButton: true
+};
+Object.defineProperty(exports, "CyberpunkSectionButton", {
+  enumerable: true,
+  get: function () {
+    return _CyberpunkSectionButton.CyberpunkSectionButton;
+  }
+});
+var _index = require("./components/index.js");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index[key];
+    }
+  });
+});
+var _CyberpunkSectionButton = require("./console/CyberpunkSectionButton.js");
+var _index2 = require("./gameUI/index.js");
+Object.keys(_index2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index2[key];
+    }
+  });
+});

package/lib/commonjs/utils/displayValue.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseDisplayValue = exports.displayValue = void 0;
+var _minimalSuperJSON = require("./minimalSuperJSON.js");
+/**
+ * Displays a string regardless the type of the data
+ * Uses minimal SuperJSON to properly serialize complex objects, avoiding [object Object].
+ * @param {unknown} value Value to be stringified
+ * @param {boolean} beautify Formats json to multiline
+ */
+const displayValue = (value, beautify = false) => {
+  const {
+    json
+  } = (0, _minimalSuperJSON.serialize)(value);
+  return JSON.stringify(json, null, beautify ? 2 : undefined);
+};
+
+/**
+ * Parses a string that was serialized with displayValue/minimal SuperJSON.
+ * Properly deserializes complex types like Date, RegExp, Map, Set, etc.
+ *
+ * @param value - The string to parse
+ * @returns The deserialized value
+ */
+exports.displayValue = displayValue;
+const parseDisplayValue = value => {
+  try {
+    const parsed = JSON.parse(value);
+    return (0, _minimalSuperJSON.deserialize)({
+      json: parsed,
+      meta: undefined
+    });
+  } catch {
+    // Fallback to regular JSON.parse if not a SuperJSON serialized value
+    return JSON.parse(value);
+  }
+};
+exports.parseDisplayValue = parseDisplayValue;

package/lib/commonjs/utils/formatting/dataFormatting.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+exports.formatNumber = formatNumber;
+exports.truncateMiddle = truncateMiddle;
+/**
+ * Shared data formatting utilities
+ */
+
+/**
+ * Format byte size to human-readable format
+ * @param bytes Size in bytes
+ * @returns Formatted size string (e.g., "1.5 KB", "2.3 MB")
+ */
+function formatBytes(bytes) {
+  if (bytes === undefined || bytes === null) return "N/A";
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+
+/**
+ * Format duration from milliseconds to human-readable format
+ * @param ms Duration in milliseconds
+ * @returns Formatted duration string (e.g., "500ms", "1.5s", "2m 30s")
+ */
+function formatDuration(ms) {
+  if (ms === undefined || ms === null) return "N/A";
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  if (ms < 60000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+  if (ms < 3600000) {
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(ms / 3600000);
+  const minutes = Math.floor(ms % 3600000 / 60000);
+  return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+}
+
+/**
+ * Format a number with thousand separators
+ * @param num The number to format
+ * @returns Formatted number string (e.g., "1,234,567")
+ */
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+
+/**
+ * Truncate a string in the middle with ellipsis
+ * @param str The string to truncate
+ * @param maxLength Maximum length before truncation
+ * @param startChars Number of characters to show at start
+ * @param endChars Number of characters to show at end
+ * @returns Truncated string
+ */
+function truncateMiddle(str, maxLength = 50, startChars = 20, endChars = 20) {
+  if (str.length <= maxLength) return str;
+  const start = str.slice(0, startChars);
+  const end = str.slice(-endChars);
+  return `${start}...${end}`;
+}

package/lib/commonjs/utils/formatting/httpFormatting.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatHttpStatus = formatHttpStatus;
+exports.getMethodColor = getMethodColor;
+exports.parseUrl = parseUrl;
+var _gameUIColors = require("../../ui/gameUI/constants/gameUIColors.js");
+/**
+ * HTTP-specific formatting utilities
+ */
+
+/**
+ * Format HTTP status code with color and meaning
+ * @param status HTTP status code
+ * @returns Object with formatted text, color, and meaning
+ */
+function formatHttpStatus(status) {
+  // 1xx Informational
+  if (status >= 100 && status < 200) {
+    return {
+      text: String(status),
+      color: _gameUIColors.gameUIColors.info,
+      meaning: "Informational"
+    };
+  }
+
+  // 2xx Success
+  if (status >= 200 && status < 300) {
+    const meanings = {
+      200: "OK",
+      201: "Created",
+      202: "Accepted",
+      204: "No Content",
+      206: "Partial Content"
+    };
+    return {
+      text: String(status),
+      color: _gameUIColors.gameUIColors.success,
+      meaning: meanings[status] || "Success"
+    };
+  }
+
+  // 3xx Redirection
+  if (status >= 300 && status < 400) {
+    const meanings = {
+      301: "Moved Permanently",
+      302: "Found",
+      303: "See Other",
+      304: "Not Modified",
+      307: "Temporary Redirect",
+      308: "Permanent Redirect"
+    };
+    return {
+      text: String(status),
+      color: _gameUIColors.gameUIColors.warning,
+      meaning: meanings[status] || "Redirect"
+    };
+  }
+
+  // 4xx Client Error
+  if (status >= 400 && status < 500) {
+    const meanings = {
+      400: "Bad Request",
+      401: "Unauthorized",
+      402: "Payment Required",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      408: "Request Timeout",
+      409: "Conflict",
+      410: "Gone",
+      422: "Unprocessable Entity",
+      429: "Too Many Requests"
+    };
+    return {
+      text: String(status),
+      color: _gameUIColors.gameUIColors.error,
+      meaning: meanings[status] || "Client Error"
+    };
+  }
+
+  // 5xx Server Error
+  if (status >= 500) {
+    const meanings = {
+      500: "Internal Server Error",
+      501: "Not Implemented",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout",
+      505: "HTTP Version Not Supported"
+    };
+    return {
+      text: String(status),
+      color: _gameUIColors.gameUIColors.error,
+      meaning: meanings[status] || "Server Error"
+    };
+  }
+  return {
+    text: String(status),
+    color: _gameUIColors.gameUIColors.muted,
+    meaning: "Unknown"
+  };
+}
+
+/**
+ * Get color for HTTP method
+ * @param method HTTP method (GET, POST, etc.)
+ * @returns Color string for the method
+ */
+function getMethodColor(method) {
+  const colors = {
+    GET: _gameUIColors.gameUIColors.success,
+    POST: _gameUIColors.gameUIColors.info,
+    PUT: _gameUIColors.gameUIColors.warning,
+    DELETE: _gameUIColors.gameUIColors.error,
+    PATCH: _gameUIColors.gameUIColors.network,
+    HEAD: _gameUIColors.gameUIColors.muted,
+    OPTIONS: _gameUIColors.gameUIColors.secondary,
+    CONNECT: _gameUIColors.gameUIColors.critical,
+    TRACE: _gameUIColors.gameUIColors.env
+  };
+  return colors[method.toUpperCase()] || _gameUIColors.gameUIColors.muted;
+}
+
+/**
+ * Parse URL into components for display
+ * @param url The URL to parse
+ * @returns URL components
+ */
+
+function parseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return {
+      //@ts-expect-error - URL is not typed
+      protocol: parsed.protocol.replace(":", ""),
+      //@ts-expect-error - URL is not typed
+      host: parsed.hostname,
+      //@ts-expect-error - URL is not typed
+      port: parsed.port || undefined,
+      //@ts-expect-error - URL is not typed
+      pathname: parsed.pathname,
+      //@ts-expect-error - URL is not typed
+      search: parsed.search || undefined,
+      //@ts-expect-error - URL is not typed
+      hash: parsed.hash || undefined
+    };
+  } catch {
+    return null;
+  }
+}

package/lib/commonjs/utils/formatting/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _dataFormatting = require("./dataFormatting.js");
+Object.keys(_dataFormatting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dataFormatting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dataFormatting[key];
+    }
+  });
+});
+var _httpFormatting = require("./httpFormatting.js");
+Object.keys(_httpFormatting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _httpFormatting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _httpFormatting[key];
+    }
+  });
+});

package/lib/commonjs/utils/getSafeAreaInsets.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSafeAreaInsets = void 0;
+var _reactNative = require("react-native");
+/**
+ * Pure JS implementation of safe area insets
+ * Detects device type and returns appropriate safe areas
+ *
+ * @returns Object with top, bottom, left, right insets and hasNotch flag
+ */
+const getSafeAreaInsets = () => {
+  const isIOS = _reactNative.Platform.OS === "ios";
+  const isAndroid = _reactNative.Platform.OS === "android";
+  const {
+    height
+  } = _reactNative.Dimensions.get("window");
+  let top = 0;
+  let bottom = 0;
+  if (isIOS) {
+    // iPhone X and later models have notch/dynamic island
+    const hasNotch = height >= 812; // iPhone X and later
+    top = hasNotch ? 44 : 20;
+    bottom = hasNotch ? 34 : 0;
+  } else if (isAndroid) {
+    // Android status bar height
+    top = _reactNative.StatusBar.currentHeight || 24;
+    bottom = 0;
+  }
+  return {
+    top,
+    bottom,
+    left: 0,
+    right: 0,
+    hasNotch: height >= 812
+  };
+};
+exports.getSafeAreaInsets = getSafeAreaInsets;

package/lib/commonjs/utils/index.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "displayValue", {
+  enumerable: true,
+  get: function () {
+    return _displayValue.displayValue;
+  }
+});
+Object.defineProperty(exports, "flattenObject", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.flattenObject;
+  }
+});
+Object.defineProperty(exports, "formatPath", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.formatPath;
+  }
+});
+Object.defineProperty(exports, "formatValue", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.formatValue;
+  }
+});
+Object.defineProperty(exports, "getCachedOptionalModule", {
+  enumerable: true,
+  get: function () {
+    return _loadOptionalModule.getCachedOptionalModule;
+  }
+});
+Object.defineProperty(exports, "getConstructorName", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.getConstructorName;
+  }
+});
+Object.defineProperty(exports, "getSafeAreaInsets", {
+  enumerable: true,
+  get: function () {
+    return _getSafeAreaInsets.getSafeAreaInsets;
+  }
+});
+Object.defineProperty(exports, "getStorageBackendType", {
+  enumerable: true,
+  get: function () {
+    return _persistentStorage.getStorageBackendType;
+  }
+});
+Object.defineProperty(exports, "getTypeColor", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.getTypeColor;
+  }
+});
+Object.defineProperty(exports, "getValueSize", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.getValueSize;
+  }
+});
+Object.defineProperty(exports, "getValueType", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.getValueType;
+  }
+});
+Object.defineProperty(exports, "isEmpty", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.isEmpty;
+  }
+});
+Object.defineProperty(exports, "isJsonSerializable", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.isJsonSerializable;
+  }
+});
+Object.defineProperty(exports, "isPersistentStorageAvailable", {
+  enumerable: true,
+  get: function () {
+    return _safeAsyncStorage.isPersistentStorageAvailable;
+  }
+});
+Object.defineProperty(exports, "isPrimitive", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.isPrimitive;
+  }
+});
+Object.defineProperty(exports, "isUsingPersistentStorage", {
+  enumerable: true,
+  get: function () {
+    return _persistentStorage.isUsingPersistentStorage;
+  }
+});
+Object.defineProperty(exports, "isValidJson", {
+  enumerable: true,
+  get: function () {
+    return _typeHelpers.isValidJson;
+  }
+});
+Object.defineProperty(exports, "loadOptionalModule", {
+  enumerable: true,
+  get: function () {
+    return _loadOptionalModule.loadOptionalModule;
+  }
+});
+Object.defineProperty(exports, "parseDisplayValue", {
+  enumerable: true,
+  get: function () {
+    return _displayValue.parseDisplayValue;
+  }
+});
+Object.defineProperty(exports, "parseValue", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.parseValue;
+  }
+});
+Object.defineProperty(exports, "persistentStorage", {
+  enumerable: true,
+  get: function () {
+    return _persistentStorage.persistentStorage;
+  }
+});
+Object.defineProperty(exports, "safeGetItem", {
+  enumerable: true,
+  get: function () {
+    return _safeAsyncStorage.safeGetItem;
+  }
+});
+Object.defineProperty(exports, "safeRemoveItem", {
+  enumerable: true,
+  get: function () {
+    return _safeAsyncStorage.safeRemoveItem;
+  }
+});
+Object.defineProperty(exports, "safeSetItem", {
+  enumerable: true,
+  get: function () {
+    return _safeAsyncStorage.safeSetItem;
+  }
+});
+Object.defineProperty(exports, "safeStringify", {
+  enumerable: true,
+  get: function () {
+    return _safeStringify.safeStringify;
+  }
+});
+Object.defineProperty(exports, "truncateText", {
+  enumerable: true,
+  get: function () {
+    return _valueFormatting.truncateText;
+  }
+});
+Object.defineProperty(exports, "useSafeAsyncStorage", {
+  enumerable: true,
+  get: function () {
+    return _safeAsyncStorage.useSafeAsyncStorage;
+  }
+});
+var _displayValue = require("./displayValue.js");
+var _getSafeAreaInsets = require("./getSafeAreaInsets.js");
+var _safeAsyncStorage = require("./safeAsyncStorage.js");
+var _persistentStorage = require("./persistentStorage.js");
+var _safeStringify = require("./safeStringify.js");
+var _typeHelpers = require("./typeHelpers.js");
+var _valueFormatting = require("./valueFormatting.js");
+var _loadOptionalModule = require("./loadOptionalModule.js");