@hanzo/ui 4.7.0 → 4.8.2

package/dist/tailwind/index.js

@@ -305,11 +305,13 @@ for (let i = 0; i <= 50; i++) {
 var z_index_tailwind_default = zIndex;
 
 // tailwind/typo-plugin/index.js
-var import_plugin = __toESM(require("tailwindcss/plugin"));
+var import_plugin = __toESM(require("tailwindcss/plugin.js"));
 var import_lodash2 = __toESM(require("lodash.merge"));
 var import_lodash3 = __toESM(require("lodash.castarray"));
 
 // util/index.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
 function round(value) {
   return Math.round(value * 100) / 100;
 }

package/dist/tailwind/index.mjs

@@ -271,11 +271,13 @@ for (let i = 0; i <= 50; i++) {
 var z_index_tailwind_default = zIndex;
 
 // tailwind/typo-plugin/index.js
-import plugin from "tailwindcss/plugin";
+import plugin from "tailwindcss/plugin.js";
 import merge from "lodash.merge";
 import castArray from "lodash.castarray";
 
 // util/index.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
 function round(value) {
   return Math.round(value * 100) / 100;
 }

package/dist/util/format-text.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// util/format-text.ts
+var format_text_exports = {};
+__export(format_text_exports, {
+  formatCamelCaseText: () => formatCamelCaseText,
+  formatText: () => formatText,
+  getVersionFromTool: () => getVersionFromTool
+});
+module.exports = __toCommonJS(format_text_exports);
+var formatText = /* @__PURE__ */ __name((text) => {
+  const camelToSpaces = text.replace(/([a-z])([A-Z])/g, "$1 $2");
+  const snakeToSpaces = camelToSpaces.replace(/_/g, " ");
+  return snakeToSpaces.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}, "formatText");
+var formatCamelCaseText = /* @__PURE__ */ __name((text) => {
+  const words = text.split(/(?=[A-Z])/);
+  const formattedWords = words.map((word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  const result = formattedWords.join(" ");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}, "formatCamelCaseText");
+var getVersionFromTool = /* @__PURE__ */ __name((toolRouterKey) => {
+  if (toolRouterKey.version) {
+    return toolRouterKey.version;
+  }
+  const parts = toolRouterKey.name.split(":::");
+  if (parts.length === 4) {
+    return parts[3];
+  }
+  return "latest";
+}, "getVersionFromTool");

package/dist/util/format-text.mjs

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// util/format-text.ts
+var formatText = /* @__PURE__ */ __name((text) => {
+  const camelToSpaces = text.replace(/([a-z])([A-Z])/g, "$1 $2");
+  const snakeToSpaces = camelToSpaces.replace(/_/g, " ");
+  return snakeToSpaces.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}, "formatText");
+var formatCamelCaseText = /* @__PURE__ */ __name((text) => {
+  const words = text.split(/(?=[A-Z])/);
+  const formattedWords = words.map((word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  const result = formattedWords.join(" ");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}, "formatCamelCaseText");
+var getVersionFromTool = /* @__PURE__ */ __name((toolRouterKey) => {
+  if (toolRouterKey.version) {
+    return toolRouterKey.version;
+  }
+  const parts = toolRouterKey.name.split(":::");
+  if (parts.length === 4) {
+    return parts[3];
+  }
+  return "latest";
+}, "getVersionFromTool");
+export {
+  formatCamelCaseText,
+  formatText,
+  getVersionFromTool
+};

package/dist/util/index.js

@@ -0,0 +1,384 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// util/index.ts
+var util_exports = {};
+__export(util_exports, {
+  ABBR_SYMBOLS_ARRAY: () => ABBR_SYMBOLS_ARRAY,
+  absoluteUrl: () => absoluteUrl,
+  asNum: () => asNum,
+  blobToBase64: () => blobToBase64,
+  cn: () => cn,
+  constrain: () => constrain,
+  containsToken: () => containsToken,
+  copyToClipboard: () => copyToClipboard,
+  createShadowRoot: () => createShadowRoot,
+  dataUrlToFile: () => dataUrlToFile,
+  debounce: () => debounce,
+  delay: () => delay,
+  formatCamelCaseText: () => formatCamelCaseText,
+  formatDate: () => formatDate,
+  formatDateToLocaleStringWithTime: () => formatDateToLocaleStringWithTime,
+  formatDateToMonthAndDay: () => formatDateToMonthAndDay,
+  formatDateToUSLocaleString: () => formatDateToUSLocaleString,
+  formatText: () => formatText,
+  getDim: () => getDim,
+  getFileExt: () => getFileExt,
+  getFileName: () => getFileName,
+  getPrimaryStartingWith: () => getPrimaryStartingWith,
+  getRelativeDateLabel: () => getRelativeDateLabel,
+  getSpecifierData: () => getSpecifierData,
+  getTShirtSize: () => getTShirtSize,
+  getTypographySize: () => getTypographySize,
+  getVersionFromTool: () => getVersionFromTool,
+  groupMessagesByDate: () => groupMessagesByDate,
+  isFileTypeImageOrPdf: () => isFileTypeImageOrPdf,
+  ldMerge: () => ldMerge,
+  pxToEm: () => pxToEm,
+  pxToRem: () => pxToRem,
+  round: () => round,
+  spreadToTransform: () => spread_to_transform_default,
+  submitRegistrationNoCodeError: () => submitRegistrationNoCodeError,
+  submitRegistrationNoCodeNonPristineError: () => submitRegistrationNoCodeNonPristineError
+});
+module.exports = __toCommonJS(util_exports);
+
+// util/date.ts
+var formatDateToUSLocaleString = /* @__PURE__ */ __name((date) => {
+  if (!date) return "-";
+  return new Date(date).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric"
+  });
+}, "formatDateToUSLocaleString");
+var formatDateToLocaleStringWithTime = /* @__PURE__ */ __name((date) => {
+  if (!date) return "-";
+  return new Date(date).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric"
+  });
+}, "formatDateToLocaleStringWithTime");
+var getRelativeDateLabel = /* @__PURE__ */ __name((date) => {
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(today.getDate() - 1);
+  if (date.toDateString() === today.toDateString()) {
+    return "today";
+  } else if (date.toDateString() === yesterday.toDateString()) {
+    return "yesterday";
+  } else {
+    return date.toDateString();
+  }
+}, "getRelativeDateLabel");
+var groupMessagesByDate = /* @__PURE__ */ __name((messages) => {
+  const groupedMessages = {};
+  for (const message of messages) {
+    const date = new Date(message.createdAt ?? "").toDateString();
+    if (!groupedMessages[date]) {
+      groupedMessages[date] = [];
+    }
+    groupedMessages[date].push(message);
+  }
+  return groupedMessages;
+}, "groupMessagesByDate");
+var formatDateToMonthAndDay = /* @__PURE__ */ __name((date) => {
+  const today = /* @__PURE__ */ new Date();
+  if (date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear()) {
+    return date.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "numeric",
+      hour12: true
+    });
+  }
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  return `${month}/${day}`;
+}, "formatDateToMonthAndDay");
+
+// util/file.ts
+var getFileName = /* @__PURE__ */ __name((fileName) => {
+  const nameParts = fileName.split(".");
+  return nameParts.slice(0, -1).join(".");
+}, "getFileName");
+var getFileExt = /* @__PURE__ */ __name((fileName) => {
+  const nameParts = fileName.split(".");
+  return nameParts.pop() || "";
+}, "getFileExt");
+var isFileTypeImageOrPdf = /* @__PURE__ */ __name((file) => {
+  if (!file) return false;
+  return file?.type.startsWith("image/") || file?.type.startsWith("application/pdf");
+}, "isFileTypeImageOrPdf");
+
+// util/create-shadow-root.ts
+var import_client = require("react-dom/client");
+function createShadowRoot(tagName, styles) {
+  const container = document.createElement(tagName);
+  const shadow = container.attachShadow({ mode: "open" });
+  const globalStyleSheet = new CSSStyleSheet();
+  globalStyleSheet.replaceSync(styles);
+  shadow.adoptedStyleSheets = [globalStyleSheet];
+  const html = document.querySelector("html");
+  html.prepend(container);
+  return (0, import_client.createRoot)(shadow);
+}
+__name(createShadowRoot, "createShadowRoot");
+
+// util/timing.ts
+function delay(e = 1e3) {
+  return new Promise((t) => setTimeout(t, e));
+}
+__name(delay, "delay");
+
+// util/blob.ts
+var blobToBase64 = /* @__PURE__ */ __name((blob) => {
+  const reader = new FileReader();
+  reader.readAsDataURL(blob);
+  return new Promise((resolve) => {
+    reader.onloadend = () => {
+      resolve(reader.result);
+    };
+  });
+}, "blobToBase64");
+var dataUrlToFile = /* @__PURE__ */ __name((dataUrl, filename) => {
+  const arr = dataUrl.split(",");
+  if (arr.length < 2) {
+    return void 0;
+  }
+  const mimeArr = arr[0].match(/:(.*?);/);
+  if (!mimeArr || mimeArr.length < 2) {
+    return void 0;
+  }
+  const mime = mimeArr[1];
+  const binaryString = atob(arr[1]);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return new File([bytes], filename, { type: mime });
+}, "dataUrlToFile");
+
+// util/copy-to-clipboard.ts
+async function copyToClipboard(text) {
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch {
+    const textarea = document.createElement("textarea");
+    textarea.style.position = "fixed";
+    textarea.style.top = "-9999px";
+    textarea.style.left = "-9999px";
+    textarea.innerText = text;
+    document.body.appendChild(textarea);
+    textarea.focus();
+    textarea.select();
+    document.execCommand("copy");
+    textarea.remove();
+  }
+}
+__name(copyToClipboard, "copyToClipboard");
+
+// util/format-text.ts
+var formatText = /* @__PURE__ */ __name((text) => {
+  const camelToSpaces = text.replace(/([a-z])([A-Z])/g, "$1 $2");
+  const snakeToSpaces = camelToSpaces.replace(/_/g, " ");
+  return snakeToSpaces.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}, "formatText");
+var formatCamelCaseText = /* @__PURE__ */ __name((text) => {
+  const words = text.split(/(?=[A-Z])/);
+  const formattedWords = words.map((word) => {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  const result = formattedWords.join(" ");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}, "formatCamelCaseText");
+var getVersionFromTool = /* @__PURE__ */ __name((toolRouterKey) => {
+  if (toolRouterKey.version) {
+    return toolRouterKey.version;
+  }
+  const parts = toolRouterKey.name.split(":::");
+  if (parts.length === 4) {
+    return parts[3];
+  }
+  return "latest";
+}, "getVersionFromTool");
+
+// util/toasts.tsx
+var import_sonner = require("sonner");
+var import_jsx_runtime = require("react/jsx-runtime");
+var submitRegistrationNoCodeNonPristineError = /* @__PURE__ */ __name(() => {
+  return import_sonner.toast.error(
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "Your Hanzo Node is currently locked by existing keys, please restore your connection or reset your Hanzo Node Storage" }),
+    { position: "bottom-center" }
+  );
+}, "submitRegistrationNoCodeNonPristineError");
+var submitRegistrationNoCodeError = /* @__PURE__ */ __name(() => {
+  return import_sonner.toast.error(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "Error connecting to your Hanzo Node" }), {
+    position: "bottom-center"
+  });
+}, "submitRegistrationNoCodeError");
+
+// util/debounce.ts
+var debounce = /* @__PURE__ */ __name((func, delay2) => {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      func(...args);
+    }, delay2);
+  };
+}, "debounce");
+
+// util/spread-to-transform.ts
+function spreadToTransform(t) {
+  let transformStrings = [];
+  const scaleVal = "scale" in t ? t.scale : void 0;
+  if (scaleVal) {
+    if (typeof scaleVal === "number") {
+      transformStrings.push(`scale(${scaleVal})`);
+    } else if (Array.isArray(scaleVal) && scaleVal.length == 2 && typeof scaleVal[0] === "number") {
+      transformStrings.push(`scale(${scaleVal[0]}, ${scaleVal[1]})`);
+    } else {
+      throw new Error("parsing MediaTransform: Unrecognized value for 'scale'!");
+    }
+  }
+  return transformStrings.length > 0 ? { transform: transformStrings.join(" ") } : {};
+}
+__name(spreadToTransform, "spreadToTransform");
+var spread_to_transform_default = spreadToTransform;
+
+// util/specifier.ts
+var getPrimaryStartingWith = /* @__PURE__ */ __name((s, toFind) => {
+  const tokenArray = s.split(" ");
+  return tokenArray.find((tok) => tok.startsWith(`${toFind}-`));
+}, "getPrimaryStartingWith");
+var getTShirtSize = /* @__PURE__ */ __name((s) => {
+  const subTokenArray = s.split("-");
+  return subTokenArray[subTokenArray.length - 1];
+}, "getTShirtSize");
+var getTypographySize = /* @__PURE__ */ __name((s) => {
+  const subTokenArray = s.split("-");
+  return subTokenArray[subTokenArray.length - 1];
+}, "getTypographySize");
+var getDim = /* @__PURE__ */ __name((s) => {
+  const subTokenArray = s.split("-");
+  const dimStr = subTokenArray[subTokenArray.length - 1];
+  if (dimStr) {
+    const dimTokenArray = s.split("x");
+    return dimTokenArray ? {
+      w: Number(dimTokenArray[0]),
+      h: Number(dimTokenArray[1])
+    } : void 0;
+  }
+  return void 0;
+}, "getDim");
+function getSpecifierData(main, getPrimary, getData, def) {
+  const primary = getPrimary(main);
+  if (primary) {
+    return getData(primary) ?? def;
+  }
+  return def ?? void 0;
+}
+__name(getSpecifierData, "getSpecifierData");
+
+// util/number-abbreviate.ts
+var ABBR_SYMBOLS_ARRAY = ["K", "M", "B", "T"];
+
+// util/index.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+__name(cn, "cn");
+function formatDate(input) {
+  const date = new Date(input);
+  return date.toLocaleDateString("en-US", {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+__name(formatDate, "formatDate");
+function absoluteUrl(path) {
+  if (typeof window !== "undefined") return path;
+  if (process.env.VERCEL_URL) return `https://${process.env.VERCEL_URL}${path}`;
+  return `http://localhost:${process.env.PORT ?? 3e3}${path}`;
+}
+__name(absoluteUrl, "absoluteUrl");
+function constrain(value, minOrConstrainTo, max) {
+  if (typeof value === "number" && typeof minOrConstrainTo === "number" && typeof max === "number") {
+    return Math.min(Math.max(value, minOrConstrainTo), max);
+  }
+  if (typeof value === "object" && typeof minOrConstrainTo === "object") {
+    const dim = value;
+    const constrainTo = minOrConstrainTo;
+    const aspectRatio = dim.w / dim.h;
+    const constrainAspectRatio = constrainTo.w / constrainTo.h;
+    if (aspectRatio > constrainAspectRatio) {
+      return {
+        w: constrainTo.w,
+        h: constrainTo.w / aspectRatio
+      };
+    } else {
+      return {
+        w: constrainTo.h * aspectRatio,
+        h: constrainTo.h
+      };
+    }
+  }
+  throw new Error("Invalid parameters for constrain function");
+}
+__name(constrain, "constrain");
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+__name(round, "round");
+function pxToRem(px, base = 16) {
+  return `${px / base}rem`;
+}
+__name(pxToRem, "pxToRem");
+function pxToEm(px, base = 16) {
+  return `${px / base}em`;
+}
+__name(pxToEm, "pxToEm");
+function containsToken(text, token) {
+  return text.toLowerCase().includes(token.toLowerCase());
+}
+__name(containsToken, "containsToken");
+function ldMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (obj && typeof obj === "object") {
+      Object.assign(result, obj);
+    }
+  }
+  return result;
+}
+__name(ldMerge, "ldMerge");
+function asNum(value, defaultValue = 0) {
+  const num = Number(value);
+  return isNaN(num) ? defaultValue : num;
+}
+__name(asNum, "asNum");