@hanzo/ui 4.6.0 → 4.8.2

package/dist/util/index.mjs

@@ -0,0 +1,363 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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
+import { createRoot } from "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 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
+import { toast } from "sonner";
+import { jsx } from "react/jsx-runtime";
+var submitRegistrationNoCodeNonPristineError = /* @__PURE__ */ __name(() => {
+  return toast.error(
+    /* @__PURE__ */ 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 toast.error(/* @__PURE__ */ 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
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(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");
+export {
+  ABBR_SYMBOLS_ARRAY,
+  absoluteUrl,
+  asNum,
+  blobToBase64,
+  cn,
+  constrain,
+  containsToken,
+  copyToClipboard,
+  createShadowRoot,
+  dataUrlToFile,
+  debounce,
+  delay,
+  formatCamelCaseText,
+  formatDate,
+  formatDateToLocaleStringWithTime,
+  formatDateToMonthAndDay,
+  formatDateToUSLocaleString,
+  formatText,
+  getDim,
+  getFileExt,
+  getFileName,
+  getPrimaryStartingWith,
+  getRelativeDateLabel,
+  getSpecifierData,
+  getTShirtSize,
+  getTypographySize,
+  getVersionFromTool,
+  groupMessagesByDate,
+  isFileTypeImageOrPdf,
+  ldMerge,
+  pxToEm,
+  pxToRem,
+  round,
+  spread_to_transform_default as spreadToTransform,
+  submitRegistrationNoCodeError,
+  submitRegistrationNoCodeNonPristineError
+};

package/frameworks/core/index.ts

@@ -0,0 +1,6 @@
+// Core utilities - framework agnostic
+// Shared utilities for all framework implementations
+
+export * from './utils'
+export * from './types'
+export * from './styles'

package/frameworks/core/utils/index.ts

@@ -0,0 +1,64 @@
+// Core utilities shared across all frameworks
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+/**
+ * Merge class names with Tailwind CSS support
+ * Works across all frameworks
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes: number, decimals = 2) {
+  if (bytes === 0) return '0 Bytes'
+
+  const k = 1024
+  const dm = decimals < 0 ? 0 : decimals
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
+}
+
+/**
+ * Debounce function
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+
+  return (...args: Parameters<T>) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId)
+    }
+
+    timeoutId = setTimeout(() => {
+      func(...args)
+    }, wait)
+  }
+}
+
+/**
+ * Throttle function
+ */
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let inThrottle: boolean
+
+  return (...args: Parameters<T>) => {
+    if (!inThrottle) {
+      func(...args)
+      inThrottle = true
+      setTimeout(() => (inThrottle = false), limit)
+    }
+  }
+}

package/frameworks/react/components/button.tsx

@@ -0,0 +1,26 @@
+import React from 'react';
+import { cn } from '../../core/utils'
+
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link'
+  size?: 'default' | 'sm' | 'lg' | 'icon'
+}
+
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant = 'default', size = 'default', ...props }, ref) => {
+    return (
+      <button
+        className={cn(
+          'inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50',
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    )
+  }
+)
+
+Button.displayName = 'Button'
+
+export default Button

package/frameworks/react/components/index.ts

@@ -0,0 +1,5 @@
+// React components
+// These will be populated with actual components
+
+export { default as Button } from './button'
+// Export more components as they are added

package/frameworks/react/hooks/index.ts

@@ -0,0 +1,5 @@
+// React hooks
+export const useDebounce = (value: any, delay: number) => {
+  // Hook implementation
+  return value
+}

package/frameworks/react/index.ts

@@ -0,0 +1,9 @@
+// React components entry point
+// Export all React components for @hanzo/ui
+
+export * from './components'
+export * from './hooks'
+export * from './utils'
+
+// Re-export core utilities
+export { cn } from '../core/utils'

package/frameworks/react/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@hanzo/ui-react",
+  "version": "1.0.0",
+  "exports": {
+    ".": "./index.ts",
+    "./components": "./components/index.ts"
+  }
+}

package/frameworks/react/utils/index.ts

@@ -0,0 +1,2 @@
+// React-specific utilities
+export { cn } from '../../core/utils'

package/frameworks/react-native/index.ts

@@ -0,0 +1,9 @@
+// React Native components entry point
+// Export all React Native components for @hanzo/ui
+
+export * from './components'
+export * from './hooks'
+export * from './utils'
+
+// Re-export core utilities (adapted for React Native)
+export { cn } from '../core/utils'

package/frameworks/react-native/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@hanzo/ui-react-native",
+  "version": "1.0.0",
+  "exports": {
+    ".": "./index.ts",
+    "./components": "./components/index.ts"
+  }
+}