nexu-app 2.0.0

package/templates/default/packages/utils/src/index.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  capitalize,
+  slugify,
+  truncate,
+  pick,
+  omit,
+  isEmpty,
+  chunk,
+  unique,
+  isEmail,
+  isUrl,
+  clamp,
+  daysBetween,
+} from './index';
+
+describe('String utilities', () => {
+  describe('capitalize', () => {
+    it('should capitalize first letter', () => {
+      expect(capitalize('hello')).toBe('Hello');
+    });
+
+    it('should return empty string for empty input', () => {
+      expect(capitalize('')).toBe('');
+    });
+  });
+
+  describe('slugify', () => {
+    it('should convert string to slug', () => {
+      expect(slugify('Hello World')).toBe('hello-world');
+    });
+
+    it('should remove special characters', () => {
+      expect(slugify('Hello! World?')).toBe('hello-world');
+    });
+  });
+
+  describe('truncate', () => {
+    it('should truncate long strings', () => {
+      expect(truncate('Hello World', 8)).toBe('Hello...');
+    });
+
+    it('should not truncate short strings', () => {
+      expect(truncate('Hello', 10)).toBe('Hello');
+    });
+  });
+});
+
+describe('Object utilities', () => {
+  describe('pick', () => {
+    it('should pick specified keys', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(pick(obj, ['a', 'c'])).toEqual({ a: 1, c: 3 });
+    });
+  });
+
+  describe('omit', () => {
+    it('should omit specified keys', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(omit(obj, ['b'])).toEqual({ a: 1, c: 3 });
+    });
+  });
+
+  describe('isEmpty', () => {
+    it('should return true for empty values', () => {
+      expect(isEmpty(null)).toBe(true);
+      expect(isEmpty(undefined)).toBe(true);
+      expect(isEmpty('')).toBe(true);
+      expect(isEmpty([])).toBe(true);
+      expect(isEmpty({})).toBe(true);
+    });
+
+    it('should return false for non-empty values', () => {
+      expect(isEmpty('hello')).toBe(false);
+      expect(isEmpty([1])).toBe(false);
+      expect(isEmpty({ a: 1 })).toBe(false);
+    });
+  });
+});
+
+describe('Array utilities', () => {
+  describe('chunk', () => {
+    it('should split array into chunks', () => {
+      expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+    });
+  });
+
+  describe('unique', () => {
+    it('should remove duplicates', () => {
+      expect(unique([1, 2, 2, 3, 3, 3])).toEqual([1, 2, 3]);
+    });
+  });
+});
+
+describe('Validation utilities', () => {
+  describe('isEmail', () => {
+    it('should validate emails', () => {
+      expect(isEmail('test@example.com')).toBe(true);
+      expect(isEmail('invalid')).toBe(false);
+    });
+  });
+
+  describe('isUrl', () => {
+    it('should validate URLs', () => {
+      expect(isUrl('https://example.com')).toBe(true);
+      expect(isUrl('not-a-url')).toBe(false);
+    });
+  });
+});
+
+describe('Number utilities', () => {
+  describe('clamp', () => {
+    it('should clamp values', () => {
+      expect(clamp(5, 0, 10)).toBe(5);
+      expect(clamp(-5, 0, 10)).toBe(0);
+      expect(clamp(15, 0, 10)).toBe(10);
+    });
+  });
+});
+
+describe('Date utilities', () => {
+  describe('daysBetween', () => {
+    it('should calculate days between dates', () => {
+      const date1 = new Date('2024-01-01');
+      const date2 = new Date('2024-01-10');
+      expect(daysBetween(date1, date2)).toBe(9);
+    });
+  });
+});

package/templates/default/packages/utils/src/index.ts

@@ -0,0 +1,154 @@
+// String utilities
+export function capitalize(str: string): string {
+  if (!str) return '';
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function slugify(str: string): string {
+  return str
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function truncate(str: string, length: number, suffix = '...'): string {
+  if (str.length <= length) return str;
+  return str.slice(0, length - suffix.length) + suffix;
+}
+
+// Object utilities
+export function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
+  const result = {} as Pick<T, K>;
+  keys.forEach(key => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+
+export function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {
+  const result = { ...obj };
+  keys.forEach(key => {
+    delete result[key];
+  });
+  return result as Omit<T, K>;
+}
+
+export function isEmpty(value: unknown): boolean {
+  if (value == null) return true;
+  if (typeof value === 'string' || Array.isArray(value)) return value.length === 0;
+  if (typeof value === 'object') return Object.keys(value).length === 0;
+  return false;
+}
+
+// Array utilities
+export function chunk<T>(array: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+
+export function unique<T>(array: T[]): T[] {
+  return [...new Set(array)];
+}
+
+export function groupBy<T, K extends string | number | symbol>(
+  array: T[],
+  keyFn: (item: T) => K
+): Record<K, T[]> {
+  return array.reduce(
+    (acc, item) => {
+      const key = keyFn(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {} as Record<K, T[]>
+  );
+}
+
+// Date utilities
+export function formatDate(date: Date, locale = 'en-US'): string {
+  return new Intl.DateTimeFormat(locale, {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  }).format(date);
+}
+
+export function isValidDate(date: unknown): date is Date {
+  return date instanceof Date && !isNaN(date.getTime());
+}
+
+export function daysBetween(date1: Date, date2: Date): number {
+  const oneDay = 24 * 60 * 60 * 1000;
+  return Math.round(Math.abs((date1.getTime() - date2.getTime()) / oneDay));
+}
+
+// Async utilities
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: { attempts?: number; delay?: number } = {}
+): Promise<T> {
+  const { attempts = 3, delay = 1000 } = options;
+  let lastError: Error | undefined;
+
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < attempts - 1) {
+        await sleep(delay);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+// Validation utilities
+export function isEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export function isUrl(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Number utilities
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+export function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export function formatNumber(num: number, locale = 'en-US'): string {
+  return new Intl.NumberFormat(locale).format(num);
+}
+
+export function formatCurrency(amount: number, currency = 'USD', locale = 'en-US'): string {
+  return new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency,
+  }).format(amount);
+}

package/templates/default/packages/utils/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../config/typescript/base.json",
+  "compilerOptions": {
+    "lib": ["ES2022", "DOM"],
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/default/packages/utils/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});

package/templates/default/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - 'apps/*'
+  - 'packages/*'