Merge pull request #2 from JustAGhosT/tembo/migrate-orchestration-utils-repos

Migrate Orchestration Utils

Author: JustAGhosT

packages/utils/package.json

@@ -14,6 +14,14 @@
     "./tailwind": {
       "import": "./dist/tailwind.js",
       "types": "./dist/tailwind.d.ts"
+    },
+    "./validation": {
+      "import": "./dist/validation/index.js",
+      "types": "./dist/validation/index.d.ts"
+    },
+    "./formatting": {
+      "import": "./dist/formatting/index.js",
+      "types": "./dist/formatting/index.d.ts"
     }
   },
   "files": [
@@ -47,7 +55,9 @@
     "codeflow",
     "utils",
     "utilities",
-    "tailwind"
+    "tailwind",
+    "validation",
+    "formatting"
   ],
   "license": "MIT",
   "repository": {

packages/utils/src/formatting/date.ts

@@ -0,0 +1,60 @@
+/**
+ * Date and time formatting utilities.
+ */
+
+/**
+ * Format datetime to string.
+ *
+ * @param date - Date object to format
+ * @param format - Format string ('iso' for ISO 8601, or custom format)
+ * @returns Formatted datetime string
+ */
+export function formatDateTime(date: Date, format: string = "default"): string {
+  if (format === "iso") {
+    return date.toISOString();
+  }
+
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+/**
+ * Format datetime as relative time (e.g., "2 hours ago").
+ *
+ * @param date - Date object
+ * @param now - Current date (defaults to now)
+ * @returns Relative time string
+ */
+export function formatRelativeTime(date: Date, now: Date = new Date()): string {
+  const delta = now.getTime() - date.getTime();
+  const seconds = Math.floor(Math.abs(delta) / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+
+  const isFuture = delta < 0;
+  const prefix = isFuture ? "in " : "";
+  const suffix = isFuture ? "" : " ago";
+
+  if (years > 0) {
+    return `${prefix}${years} year${years > 1 ? "s" : ""}${suffix}`;
+  } else if (months > 0) {
+    return `${prefix}${months} month${months > 1 ? "s" : ""}${suffix}`;
+  } else if (days > 0) {
+    return `${prefix}${days} day${days > 1 ? "s" : ""}${suffix}`;
+  } else if (hours > 0) {
+    return `${prefix}${hours} hour${hours > 1 ? "s" : ""}${suffix}`;
+  } else if (minutes > 0) {
+    return `${prefix}${minutes} minute${minutes > 1 ? "s" : ""}${suffix}`;
+  } else {
+    return isFuture ? "in a moment" : "just now";
+  }
+}

packages/utils/src/formatting/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Formatting utilities.
+ */
+
+export * from "./date";
+export * from "./number";
+export * from "./string";

packages/utils/src/formatting/number.ts

@@ -0,0 +1,66 @@
+/**
+ * Number formatting utilities.
+ */
+
+/**
+ * Format number with thousands separator and decimal places.
+ *
+ * @param value - Number to format
+ * @param decimals - Number of decimal places
+ * @param thousandsSeparator - Thousands separator character
+ * @param decimalSeparator - Decimal separator character
+ * @returns Formatted number string
+ */
+export function formatNumber(
+  value: number,
+  decimals: number = 2,
+  thousandsSeparator: string = ",",
+  decimalSeparator: string = "."
+): string {
+  return value.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  })
+    .replace(/,/g, thousandsSeparator)
+    .replace(/\./g, decimalSeparator);
+}
+
+/**
+ * Format bytes to human-readable string.
+ *
+ * @param bytesValue - Number of bytes
+ * @param binary - Use binary (1024) or decimal (1000) units
+ * @returns Formatted string (e.g., "1.5 MB")
+ */
+export function formatBytes(bytesValue: number, binary: boolean = false): string {
+  const base = binary ? 1024 : 1000;
+  const units = binary
+    ? ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
+    : ["B", "KB", "MB", "GB", "TB", "PB"];
+
+  if (bytesValue === 0) {
+    return "0 B";
+  }
+
+  let unitIndex = 0;
+  let value = bytesValue;
+
+  while (value >= base && unitIndex < units.length - 1) {
+    value /= base;
+    unitIndex++;
+  }
+
+  return `${value.toFixed(2)} ${units[unitIndex]}`;
+}
+
+/**
+ * Format number as percentage.
+ *
+ * @param value - Number to format (0.0 to 1.0 or 0 to 100)
+ * @param decimals - Number of decimal places
+ * @returns Formatted percentage string
+ */
+export function formatPercentage(value: number, decimals: number = 1): string {
+  const percentage = value <= 1.0 ? value * 100 : value;
+  return `${percentage.toFixed(decimals)}%`;
+}

packages/utils/src/formatting/string.ts

@@ -0,0 +1,85 @@
+/**
+ * String formatting utilities.
+ */
+
+/**
+ * Truncate string to maximum length.
+ *
+ * @param value - String to truncate
+ * @param maxLength - Maximum length (including suffix)
+ * @param suffix - Suffix to add if truncated
+ * @param preserveWords - Whether to preserve word boundaries
+ * @returns Truncated string
+ */
+export function truncateString(
+  value: string,
+  maxLength: number,
+  suffix: string = "...",
+  preserveWords: boolean = true
+): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  if (preserveWords) {
+    const truncated = value.substring(0, maxLength - suffix.length);
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > maxLength * 0.5) {
+      return truncated.substring(0, lastSpace) + suffix;
+    }
+    return truncated + suffix;
+  }
+
+  return value.substring(0, maxLength - suffix.length) + suffix;
+}
+
+/**
+ * Convert string to URL-friendly slug.
+ *
+ * @param value - String to slugify
+ * @param separator - Word separator character
+ * @returns Slugified string
+ */
+export function slugify(value: string, separator: string = "-"): string {
+  return value
+    .toLowerCase()
+    .trim()
+    .replace(/[\s_]+/g, separator)
+    .replace(/[^\w\-]+/g, "")
+    .replace(new RegExp(`${separator}+`, "g"), separator)
+    .replace(new RegExp(`^${separator}|${separator}$`, "g"), "");
+}
+
+/**
+ * Convert camelCase to snake_case.
+ *
+ * @param value - CamelCase string
+ * @returns snake_case string
+ */
+export function camelToSnake(value: string): string {
+  return value
+    .replace(/([A-Z])/g, "_$1")
+    .toLowerCase()
+    .replace(/^_/, "");
+}
+
+/**
+ * Convert snake_case to camelCase.
+ *
+ * @param value - snake_case string
+ * @param capitalizeFirst - Whether to capitalize first letter (PascalCase)
+ * @returns camelCase or PascalCase string
+ */
+export function snakeToCamel(
+  value: string,
+  capitalizeFirst: boolean = false
+): string {
+  const components = value.split("_");
+  const first = capitalizeFirst
+    ? components[0].charAt(0).toUpperCase() + components[0].slice(1)
+    : components[0];
+  const rest = components
+    .slice(1)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1));
+  return first + rest.join("");
+}

packages/utils/src/index.ts

@@ -4,3 +4,9 @@
 
 // Re-export tailwind utilities
 export { cn, type ClassValue } from "./tailwind";
+
+// Export validation utilities
+export * from "./validation";
+
+// Export formatting utilities
+export * from "./formatting";

packages/utils/src/validation/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Validation utilities.
+ */
+
+export * from "./url";

packages/utils/src/validation/url.ts

@@ -0,0 +1,54 @@
+/**
+ * URL validation utilities.
+ */
+
+export interface UrlValidationResult {
+  valid: boolean;
+  error?: string;
+}
+
+/**
+ * Validate URL format.
+ *
+ * @param url - URL string to validate
+ * @param schemes - Allowed URL schemes (optional)
+ * @returns Validation result with valid flag and optional error message
+ */
+export function validateUrl(
+  url: string,
+  schemes?: string[]
+): UrlValidationResult {
+  if (!url || typeof url !== "string") {
+    return { valid: false, error: "URL must be a non-empty string" };
+  }
+
+  try {
+    const parsed = new URL(url);
+    const scheme = parsed.protocol.slice(0, -1); // Remove trailing ':'
+
+    if (schemes && !schemes.includes(scheme)) {
+      return {
+        valid: false,
+        error: `URL scheme must be one of: ${schemes.join(", ")}`,
+      };
+    }
+
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Invalid URL format: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Check if URL is valid.
+ *
+ * @param url - URL string to check
+ * @param schemes - Allowed URL schemes (optional)
+ * @returns True if URL is valid, false otherwise
+ */
+export function isValidUrl(url: string, schemes?: string[]): boolean {
+  return validateUrl(url, schemes).valid;
+}