skiff-utils

import { isPremiumUsername, getPremiumUsernamePrice } from 'skiff-utils';

// Check if username is premium (familiar name or <4 chars)
const isPremium = isPremiumUsername('alice');
// true

// Get pricing for premium usernames
const price = getPremiumUsernamePrice('joe');
// 80 (in dollars)

import { 
  isWalletAddress, 
  isNameServiceAddress,
  isCryptoAddress 
} from 'skiff-utils';

// Check if alias is a wallet address
isWalletAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
// true

// Check for ENS/ICNS/Bonfida name services
isNameServiceAddress('alice.eth');
// true

// Check full email for crypto association
isCryptoAddress('[email protected]');
// true

import { getCategorizedAliases, isShortAlias } from 'skiff-utils';

const aliases = [
  '[email protected]',
  '[email protected]',
  '[email protected]',
  '[email protected]'
];

const categorized = getCategorizedAliases(aliases);
// Returns:
// {
//   cryptoAliases: ['[email protected]'],
//   nonCryptoAliases: ['[email protected]', '[email protected]', '[email protected]'],
//   genericSkiffAliases: ['[email protected]', '[email protected]'],
//   shortGenericSkiffAliases: ['[email protected]']
// }

import { 
  bytesToMb, 
  mbToBytes, 
  bytesToHumanReadable,
  fileSizeStringToBytes
} from 'skiff-utils';

// Convert between units
const mb = bytesToMb(5000000);
// 5

const bytes = mbToBytes(10);
// 10000000

// Convert to human-readable format
bytesToHumanReadable(1500);
// "2 KB" (minimum display is 1 KB)

bytesToHumanReadable(5000000);
// "5.0 MB"

bytesToHumanReadable(3500000000);
// "3.5 GB"

// Parse human-readable strings to bytes
fileSizeStringToBytes('5 MB');
// 5000000

import { sanitizeURL, removeAllWhitespace } from 'skiff-utils';

// Sanitize potentially malicious URLs
sanitizeURL('javascript:alert(1)');
// 'about:blank'

sanitizeURL('google.com');
// 'https://google.com'

sanitizeURL('https://example.com');
// 'https://example.com'

// Remove whitespace
removeAllWhitespace('hello   world  \n  test');
// 'helloworldtest'

import { getContentSnippet } from 'skiff-utils';

// Create short preview of content (defaults to CONTENT_SNIPPET_SIZE)
const snippet = getContentSnippet('This is a very long email message...');
// Returns first N characters for preview

import { 
  dateToMonthAndOrdinalDay, 
  getFutureDate,
  daysToMilliseconds 
} from 'skiff-utils';

// Format date as "April 1st"
const formatted = dateToMonthAndOrdinalDay(new Date('2024-04-01'));
// "April 1st"

// Get future date
const future = getFutureDate(7);
// Date 7 days from now

// Convert days to milliseconds
const ms = daysToMilliseconds(30);
// 2592000000

import { 
  assertExists, 
  assert,
  filterExists,
  filterTruthy 
} from 'skiff-utils';

// Assert value exists (throws if null/undefined)
function processUser(user: User | null) {
  assertExists(user, 'User must be defined');
  // TypeScript now knows user is non-null
  return user.name;
}

// Assert condition is true
assert(password.length >= 8, 'Password too short');

// Filter out null/undefined from arrays
const items = [1, null, 2, undefined, 3];
const defined = items.filter(filterExists);
// [1, 2, 3] with type number[]

// Filter out all falsy values
const values = [1, 0, '', 'hello', false, true];
const truthy = values.filter(filterTruthy);
// [1, 'hello', true]

import type { 
  Optional, 
  WithRequired,
  OmitStrict,
  RequireAtLeastOne 
} from 'skiff-utils';

// Make specific keys optional
type User = { name: string; email: string; age: number };
type PartialUser = Optional<User, 'age'>;
// { name: string; email: string; age?: number }

// Make specific keys required
type MaybeUser = { name?: string; email?: string };
type RequiredUser = WithRequired<MaybeUser, 'name'>;
// { name: string; email?: string }

// Strict omit (K must exist in T)
type NoAge = OmitStrict<User, 'age'>;
// { name: string; email: string }

// Require at least one key
type ContactMethod = RequireAtLeastOne<{
  email: string;
  phone: string;
}>;
// Must have email, phone, or both

import { 
  isSolanaAddress,
  isCosmosHubAddress,
  isENSName,
  isBonfidaName,
  isICNSName 
} from 'skiff-utils';

// Validate various blockchain addresses
isSolanaAddress('DYw8j...');
isCosmosHubAddress('cosmos1...');

// Check name service formats
isENSName('alice.eth');
isBonfidaName('alice.sol');
isICNSName('alice.osmo');

import { 
  CONTENT_SNIPPET_SIZE,
  SHORT_ALIAS_MIN_LENGTH,
  SKIFF_ALIAS_MIN_LENGTH 
} from 'skiff-utils';

// Default content preview length
CONTENT_SNIPPET_SIZE; // 120

// Alias length constraints
SHORT_ALIAS_MIN_LENGTH; // 4
SKIFF_ALIAS_MIN_LENGTH; // 6

import { /* subscription tier utilities */ } from 'skiff-utils';

// Functions for managing subscription tiers and limits
// Used to determine feature availability based on user's plan

{
  "dependencies": {
    "skiff-utils": "workspace:libs/skiff-utils"
  }
}