@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/snippets/node/cache.ts

@@ -0,0 +1,116 @@
+/**
+ * LRU Cache with TTL support
+ */
+
+interface CacheEntry<T> {
+  value: T;
+  expiresAt: number;
+}
+
+export class LRUCache<T> {
+  private cache: Map<string, CacheEntry<T>>;
+  private readonly maxSize: number;
+  private readonly defaultTTL: number;
+
+  constructor(options: { maxSize?: number; defaultTTL?: number } = {}) {
+    this.cache = new Map();
+    this.maxSize = options.maxSize ?? 100;
+    this.defaultTTL = options.defaultTTL ?? 5 * 60 * 1000; // 5 minutes
+  }
+
+  get(key: string): T | undefined {
+    const entry = this.cache.get(key);
+
+    if (!entry) {
+      return undefined;
+    }
+
+    // Check if expired
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    // Move to end (most recently used)
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+
+    return entry.value;
+  }
+
+  set(key: string, value: T, ttl?: number): void {
+    // Delete if exists to update position
+    this.cache.delete(key);
+
+    // Evict oldest if at capacity
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+
+    this.cache.set(key, {
+      value,
+      expiresAt: Date.now() + (ttl ?? this.defaultTTL),
+    });
+  }
+
+  has(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  delete(key: string): boolean {
+    return this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Get or set a value using a factory function
+   */
+  async getOrSet(key: string, factory: () => Promise<T>, ttl?: number): Promise<T> {
+    const cached = this.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const value = await factory();
+    this.set(key, value, ttl);
+    return value;
+  }
+
+  /**
+   * Clean up expired entries
+   */
+  cleanup(): number {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+}
+
+// Default instance
+export const cache = new LRUCache();

package/dist/resources/snippets/node/date.ts

@@ -0,0 +1,126 @@
+/**
+ * Date formatting and manipulation utilities
+ */
+
+/**
+ * Format date to string
+ */
+export function formatDate(date: Date | string | number, format: string = "YYYY-MM-DD"): string {
+  const d = new Date(date);
+
+  const tokens: Record<string, string> = {
+    YYYY: d.getFullYear().toString(),
+    YY: d.getFullYear().toString().slice(-2),
+    MM: (d.getMonth() + 1).toString().padStart(2, "0"),
+    M: (d.getMonth() + 1).toString(),
+    DD: d.getDate().toString().padStart(2, "0"),
+    D: d.getDate().toString(),
+    HH: d.getHours().toString().padStart(2, "0"),
+    H: d.getHours().toString(),
+    mm: d.getMinutes().toString().padStart(2, "0"),
+    m: d.getMinutes().toString(),
+    ss: d.getSeconds().toString().padStart(2, "0"),
+    s: d.getSeconds().toString(),
+  };
+
+  let result = format;
+  for (const [token, value] of Object.entries(tokens)) {
+    result = result.replace(new RegExp(token, "g"), value);
+  }
+
+  return result;
+}
+
+/**
+ * Get relative time string (e.g., "2 hours ago")
+ */
+export function timeAgo(date: Date | string | number): string {
+  const d = new Date(date);
+  const now = new Date();
+  const seconds = Math.floor((now.getTime() - d.getTime()) / 1000);
+
+  const intervals = [
+    { label: "year", seconds: 31536000 },
+    { label: "month", seconds: 2592000 },
+    { label: "week", seconds: 604800 },
+    { label: "day", seconds: 86400 },
+    { label: "hour", seconds: 3600 },
+    { label: "minute", seconds: 60 },
+    { label: "second", seconds: 1 },
+  ];
+
+  for (const interval of intervals) {
+    const count = Math.floor(seconds / interval.seconds);
+    if (count >= 1) {
+      return `${count} ${interval.label}${count > 1 ? "s" : ""} ago`;
+    }
+  }
+
+  return "just now";
+}
+
+/**
+ * Add days to date
+ */
+export function addDays(date: Date | string | number, days: number): Date {
+  const d = new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+
+/**
+ * Add months to date
+ */
+export function addMonths(date: Date | string | number, months: number): Date {
+  const d = new Date(date);
+  d.setMonth(d.getMonth() + months);
+  return d;
+}
+
+/**
+ * Get start of day
+ */
+export function startOfDay(date: Date | string | number): Date {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+/**
+ * Get end of day
+ */
+export function endOfDay(date: Date | string | number): Date {
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+
+/**
+ * Check if date is today
+ */
+export function isToday(date: Date | string | number): boolean {
+  const d = new Date(date);
+  const today = new Date();
+  return (
+    d.getDate() === today.getDate() &&
+    d.getMonth() === today.getMonth() &&
+    d.getFullYear() === today.getFullYear()
+  );
+}
+
+/**
+ * Get difference between two dates in days
+ */
+export function diffInDays(date1: Date | string | number, date2: Date | string | number): number {
+  const d1 = new Date(date1);
+  const d2 = new Date(date2);
+  const diffTime = Math.abs(d2.getTime() - d1.getTime());
+  return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+}
+
+/**
+ * Check if date is valid
+ */
+export function isValidDate(date: unknown): date is Date {
+  return date instanceof Date && !isNaN(date.getTime());
+}

package/dist/resources/snippets/node/logger.ts

@@ -0,0 +1,104 @@
+/**
+ * Colorful console logger utility
+ */
+
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+
+  // Foreground colors
+  black: "\x1b[30m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+
+  // Background colors
+  bgRed: "\x1b[41m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgBlue: "\x1b[44m",
+} as const;
+
+function colorize(text: string, color: keyof typeof colors): string {
+  return `${colors[color]}${text}${colors.reset}`;
+}
+
+function timestamp(): string {
+  return new Date().toISOString().slice(11, 23);
+}
+
+export const logger = {
+  info(message: string, ...args: unknown[]): void {
+    console.log(colorize(`[${timestamp()}]`, "dim"), colorize("INFO", "blue"), message, ...args);
+  },
+
+  success(message: string, ...args: unknown[]): void {
+    console.log(
+      colorize(`[${timestamp()}]`, "dim"),
+      colorize("SUCCESS", "green"),
+      message,
+      ...args,
+    );
+  },
+
+  warn(message: string, ...args: unknown[]): void {
+    console.warn(colorize(`[${timestamp()}]`, "dim"), colorize("WARN", "yellow"), message, ...args);
+  },
+
+  error(message: string, ...args: unknown[]): void {
+    console.error(colorize(`[${timestamp()}]`, "dim"), colorize("ERROR", "red"), message, ...args);
+  },
+
+  debug(message: string, ...args: unknown[]): void {
+    if (process.env.DEBUG) {
+      console.log(
+        colorize(`[${timestamp()}]`, "dim"),
+        colorize("DEBUG", "magenta"),
+        message,
+        ...args,
+      );
+    }
+  },
+
+  /**
+   * Log with custom label
+   */
+  label(label: string, message: string, ...args: unknown[]): void {
+    console.log(
+      colorize(`[${timestamp()}]`, "dim"),
+      colorize(label.toUpperCase(), "cyan"),
+      message,
+      ...args,
+    );
+  },
+
+  /**
+   * Log a separator line
+   */
+  separator(char = "─", length = 50): void {
+    console.log(colorize(char.repeat(length), "dim"));
+  },
+
+  /**
+   * Log a boxed message
+   */
+  box(title: string, content: string[]): void {
+    const maxLen = Math.max(title.length, ...content.map((c) => c.length));
+    const border = "─".repeat(maxLen + 2);
+
+    console.log(`┌${border}┐`);
+    console.log(`│ ${colorize(title.padEnd(maxLen), "bright")} │`);
+    console.log(`├${border}┤`);
+    content.forEach((line) => {
+      console.log(`│ ${line.padEnd(maxLen)} │`);
+    });
+    console.log(`└${border}┘`);
+  },
+};
+
+export default logger;

package/dist/resources/snippets/node/validation.ts

@@ -0,0 +1,132 @@
+/**
+ * Common validation utility functions
+ */
+
+/**
+ * Check if value is a valid email
+ */
+export function isEmail(value: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+
+/**
+ * Check if value is a valid URL
+ */
+export function isUrl(value: string): boolean {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if value is a valid phone number (basic international format)
+ */
+export function isPhone(value: string): boolean {
+  const phoneRegex = /^\+?[\d\s-()]{10,}$/;
+  return phoneRegex.test(value);
+}
+
+/**
+ * Check if value is empty (null, undefined, empty string, empty array, empty object)
+ */
+export function isEmpty(value: unknown): boolean {
+  if (value === null || value === undefined) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+/**
+ * Check if value is a valid UUID
+ */
+export function isUUID(value: string): boolean {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(value);
+}
+
+/**
+ * Check if value is a valid date string
+ */
+export function isDateString(value: string): boolean {
+  const date = new Date(value);
+  return !isNaN(date.getTime());
+}
+
+/**
+ * Check if value is within range
+ */
+export function isInRange(value: number, min: number, max: number): boolean {
+  return value >= min && value <= max;
+}
+
+/**
+ * Check if string matches minimum length
+ */
+export function minLength(value: string, length: number): boolean {
+  return value.length >= length;
+}
+
+/**
+ * Check if string matches maximum length
+ */
+export function maxLength(value: string, length: number): boolean {
+  return value.length <= length;
+}
+
+/**
+ * Check if value matches pattern
+ */
+export function matches(value: string, pattern: RegExp): boolean {
+  return pattern.test(value);
+}
+
+/**
+ * Validate password strength
+ */
+export function isStrongPassword(
+  value: string,
+  options: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSymbols?: boolean;
+  } = {},
+): { valid: boolean; errors: string[] } {
+  const {
+    minLength: min = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumbers = true,
+    requireSymbols = false,
+  } = options;
+
+  const errors: string[] = [];
+
+  if (value.length < min) {
+    errors.push(`Password must be at least ${min} characters`);
+  }
+
+  if (requireUppercase && !/[A-Z]/.test(value)) {
+    errors.push("Password must contain at least one uppercase letter");
+  }
+
+  if (requireLowercase && !/[a-z]/.test(value)) {
+    errors.push("Password must contain at least one lowercase letter");
+  }
+
+  if (requireNumbers && !/\d/.test(value)) {
+    errors.push("Password must contain at least one number");
+  }
+
+  if (requireSymbols && !/[!@#$%^&*(),.?":{}|<>]/.test(value)) {
+    errors.push("Password must contain at least one symbol");
+  }
+
+  return { valid: errors.length === 0, errors };
+}

package/dist/resources/snippets/react/useDebounce.ts

@@ -0,0 +1,90 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+
+/**
+ * Debounce a value
+ */
+export function useDebounce<T>(value: T, delay: number = 500): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+
+  return debouncedValue;
+}
+
+/**
+ * Debounce a callback function
+ */
+export function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(
+  callback: T,
+  delay: number = 500,
+): (...args: Parameters<T>) => void {
+  const timeoutRef = useRef<ReturnType<typeof setTimeout>>();
+  const callbackRef = useRef(callback);
+
+  // Update callback ref when callback changes
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+
+  return useCallback(
+    (...args: Parameters<T>) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+
+      timeoutRef.current = setTimeout(() => {
+        callbackRef.current(...args);
+      }, delay);
+    },
+    [delay],
+  );
+}
+
+/**
+ * Debounce a value with immediate option
+ */
+export function useDebounceWithImmediate<T>(
+  value: T,
+  delay: number = 500,
+  immediate: boolean = false,
+): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+  const isFirstRender = useRef(true);
+
+  useEffect(() => {
+    if (immediate && isFirstRender.current) {
+      isFirstRender.current = false;
+      setDebouncedValue(value);
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay, immediate]);
+
+  return debouncedValue;
+}
+
+export default useDebounce;

package/dist/resources/snippets/registry.json

@@ -0,0 +1,65 @@
+{
+  "cache": {
+    "name": "Cache",
+    "description": "LRU cache utility with TTL support",
+    "files": ["cache.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "node",
+    "category": "utils"
+  },
+  "logger": {
+    "name": "Logger",
+    "description": "Colorful console logger utility",
+    "files": ["logger.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "node",
+    "category": "utils"
+  },
+  "validation": {
+    "name": "Validation",
+    "description": "Common validation utility functions",
+    "files": ["validation.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "node",
+    "category": "utils"
+  },
+  "date": {
+    "name": "Date",
+    "description": "Date formatting and manipulation utilities",
+    "files": ["date.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "node",
+    "category": "utils"
+  },
+  "useAsync": {
+    "name": "useAsync",
+    "description": "Vue composable for async operations with loading/error states",
+    "files": ["useAsync.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "vue",
+    "category": "composables"
+  },
+  "usePagination": {
+    "name": "usePagination",
+    "description": "Vue composable for pagination logic",
+    "files": ["usePagination.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "vue",
+    "category": "composables"
+  },
+  "useDebounce": {
+    "name": "useDebounce",
+    "description": "Debounce hook for React",
+    "files": ["useDebounce.ts"],
+    "dependencies": [],
+    "devDependencies": [],
+    "framework": "react",
+    "category": "hooks"
+  }
+}