{"id":"acb9299f-ce2a-4ed3-a5fa-565c1d1115bd","shortId":"a3yLev","kind":"skill","title":"fp-data-transforms","tagline":"Everyday data transformations using functional patterns - arrays, objects, grouping, aggregation, and null-safe access","description":"# Practical Data Transformations\n\nThis skill covers the data transformations you do every day: working with arrays, reshaping objects, normalizing API responses, grouping data, and safely accessing nested values. Each section shows the imperative approach first, then the functional equivalent, with honest assessments of when each approach shines.\n\n## When to Use\n- You need to transform arrays, objects, grouped data, or nested values in TypeScript.\n- The task involves reshaping API responses, null-safe access, aggregation, or normalization.\n- You want practical functional patterns for everyday data work instead of low-level loops.\n\n---\n\n## Table of Contents\n\n1. [Array Operations](#1-array-operations)\n2. [Object Transformations](#2-object-transformations)\n3. [Data Normalization](#3-data-normalization)\n4. [Grouping and Aggregation](#4-grouping-and-aggregation)\n5. [Null-Safe Access](#5-null-safe-access)\n6. [Real-World Examples](#6-real-world-examples)\n7. [When to Use What](#7-when-to-use-what)\n\n---\n\n## 1. Array Operations\n\nArray operations are the bread and butter of data transformation. Let's replace verbose loops with expressive, chainable operations.\n\n### Map: Transform Every Element\n\n**The Task**: Convert an array of prices from cents to dollars.\n\n#### Imperative Approach\n\n```typescript\nconst pricesInCents = [999, 1499, 2999, 4999];\n\nfunction convertToDollars(prices: number[]): number[] {\n  const result: number[] = [];\n  for (let i = 0; i < prices.length; i++) {\n    result.push(prices[i] / 100);\n  }\n  return result;\n}\n\nconst dollars = convertToDollars(pricesInCents);\n// [9.99, 14.99, 29.99, 49.99]\n```\n\n#### Functional Approach\n\n```typescript\nconst pricesInCents = [999, 1499, 2999, 4999];\n\nconst toDollars = (cents: number): number => cents / 100;\n\nconst dollars = pricesInCents.map(toDollars);\n// [9.99, 14.99, 29.99, 49.99]\n```\n\n**Why functional is better here**: The intent is immediately clear. `map` says \"transform each element.\" The transformation logic (`toDollars`) is named and reusable. No index management, no manual array building.\n\n### Filter: Keep What Matches\n\n**The Task**: Get all active users from a list.\n\n#### Imperative Approach\n\n```typescript\ninterface User {\n  id: string;\n  name: string;\n  isActive: boolean;\n}\n\nfunction getActiveUsers(users: User[]): User[] {\n  const result: User[] = [];\n  for (const user of users) {\n    if (user.isActive) {\n      result.push(user);\n    }\n  }\n  return result;\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst isActive = (user: User): boolean => user.isActive;\n\nconst activeUsers = users.filter(isActive);\n\n// Or inline for simple predicates\nconst activeUsers = users.filter(user => user.isActive);\n```\n\n**Why functional is better here**: The predicate (`isActive`) is separated from the iteration logic. You can reuse, test, and compose predicates independently.\n\n### Reduce: Accumulate Into Something New\n\n**The Task**: Calculate the total price of items in a cart.\n\n#### Imperative Approach\n\n```typescript\ninterface CartItem {\n  name: string;\n  price: number;\n  quantity: number;\n}\n\nfunction calculateTotal(items: CartItem[]): number {\n  let total = 0;\n  for (const item of items) {\n    total += item.price * item.quantity;\n  }\n  return total;\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst calculateTotal = (items: CartItem[]): number =>\n  items.reduce(\n    (total, item) => total + item.price * item.quantity,\n    0\n  );\n\n// Or break out the line total calculation\nconst lineTotal = (item: CartItem): number => item.price * item.quantity;\n\nconst calculateTotal = (items: CartItem[]): number =>\n  items.map(lineTotal).reduce((a, b) => a + b, 0);\n```\n\n**Honest assessment**: For simple sums, the imperative loop is actually quite readable. The functional version shines when you need to compose the accumulation with other transformations, or when the reduction logic is complex enough to benefit from being named.\n\n### Chaining: Combine Operations\n\n**The Task**: Get the names of all active premium users, sorted alphabetically.\n\n#### Imperative Approach\n\n```typescript\ninterface User {\n  id: string;\n  name: string;\n  isActive: boolean;\n  tier: 'free' | 'premium';\n}\n\nfunction getActivePremiumNames(users: User[]): string[] {\n  const result: string[] = [];\n  for (const user of users) {\n    if (user.isActive && user.tier === 'premium') {\n      result.push(user.name);\n    }\n  }\n  result.sort((a, b) => a.localeCompare(b));\n  return result;\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst getActivePremiumNames = (users: User[]): string[] =>\n  users\n    .filter(user => user.isActive)\n    .filter(user => user.tier === 'premium')\n    .map(user => user.name)\n    .sort((a, b) => a.localeCompare(b));\n\n// Or with named predicates for reuse\nconst isActive = (user: User): boolean => user.isActive;\nconst isPremium = (user: User): boolean => user.tier === 'premium';\nconst getName = (user: User): string => user.name;\nconst alphabetically = (a: string, b: string): number => a.localeCompare(b);\n\nconst getActivePremiumNames = (users: User[]): string[] =>\n  users\n    .filter(isActive)\n    .filter(isPremium)\n    .map(getName)\n    .sort(alphabetically);\n```\n\n**Why functional is better here**: Each step in the chain has a single responsibility. You can read the transformation as a series of steps: \"filter active, filter premium, get names, sort.\" Adding or removing a step is trivial.\n\n### Using fp-ts Array Module\n\nfp-ts provides additional array utilities with better composition support:\n\n```typescript\nimport * as A from 'fp-ts/Array';\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\n// Safe head (first element)\nconst first = pipe(\n  [1, 2, 3],\n  A.head\n); // Some(1)\n\nconst firstOfEmpty = pipe(\n  [] as number[],\n  A.head\n); // None\n\n// Safe lookup by index\nconst third = pipe(\n  ['a', 'b', 'c', 'd'],\n  A.lookup(2)\n); // Some('c')\n\n// Find with predicate\nconst found = pipe(\n  users,\n  A.findFirst(user => user.id === 'abc123')\n); // Option<User>\n\n// Partition into two groups\nconst [inactive, active] = pipe(\n  users,\n  A.partition(user => user.isActive)\n);\n\n// Take first N elements\nconst topThree = pipe(\n  sortedScores,\n  A.takeLeft(3)\n);\n\n// Unique values\nconst uniqueTags = pipe(\n  allTags,\n  A.uniq({ equals: (a, b) => a === b })\n);\n```\n\n---\n\n## 2. Object Transformations\n\nObjects need reshaping constantly: picking fields, omitting sensitive data, merging settings, and updating nested values.\n\n### Pick: Select Specific Fields\n\n**The Task**: Extract only the public fields from a user object.\n\n#### Imperative Approach\n\n```typescript\ninterface User {\n  id: string;\n  name: string;\n  email: string;\n  passwordHash: string;\n  internalNotes: string;\n}\n\nfunction getPublicUser(user: User): { id: string; name: string; email: string } {\n  return {\n    id: user.id,\n    name: user.name,\n    email: user.email,\n  };\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic pick utility\nconst pick = <T extends object, K extends keyof T>(\n  keys: K[]\n) => (obj: T): Pick<T, K> =>\n  keys.reduce(\n    (result, key) => {\n      result[key] = obj[key];\n      return result;\n    },\n    {} as Pick<T, K>\n  );\n\nconst getPublicUser = pick<User, 'id' | 'name' | 'email'>(['id', 'name', 'email']);\n\nconst publicUser = getPublicUser(user);\n```\n\n**Why functional is better here**: The `pick` utility is reusable across your codebase. Type safety ensures you can only pick keys that exist.\n\n### Omit: Remove Specific Fields\n\n**The Task**: Remove sensitive fields before logging.\n\n#### Imperative Approach\n\n```typescript\nfunction sanitizeForLogging(user: User): Omit<User, 'passwordHash' | 'internalNotes'> {\n  const { passwordHash, internalNotes, ...safe } = user;\n  return safe;\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic omit utility\nconst omit = <T extends object, K extends keyof T>(\n  keys: K[]\n) => (obj: T): Omit<T, K> => {\n  const result = { ...obj };\n  for (const key of keys) {\n    delete result[key];\n  }\n  return result as Omit<T, K>;\n};\n\nconst sanitizeForLogging = omit<User, 'passwordHash' | 'internalNotes'>([\n  'passwordHash',\n  'internalNotes',\n]);\n```\n\n**Honest assessment**: For one-off omits, destructuring (the imperative approach) is perfectly fine and very readable. The functional `omit` utility pays off when you have many such transformations or need to compose them.\n\n### Merge: Combine Objects\n\n**The Task**: Merge user settings with defaults.\n\n#### Imperative Approach\n\n```typescript\ninterface Settings {\n  theme: 'light' | 'dark';\n  fontSize: number;\n  notifications: boolean;\n  language: string;\n}\n\nfunction mergeSettings(\n  defaults: Settings,\n  userSettings: Partial<Settings>\n): Settings {\n  return {\n    theme: userSettings.theme !== undefined ? userSettings.theme : defaults.theme,\n    fontSize: userSettings.fontSize !== undefined ? userSettings.fontSize : defaults.fontSize,\n    notifications: userSettings.notifications !== undefined\n      ? userSettings.notifications\n      : defaults.notifications,\n    language: userSettings.language !== undefined ? userSettings.language : defaults.language,\n  };\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst mergeSettings = (\n  defaults: Settings,\n  userSettings: Partial<Settings>\n): Settings => ({\n  ...defaults,\n  ...userSettings,\n});\n\n// Usage\nconst defaults: Settings = {\n  theme: 'light',\n  fontSize: 14,\n  notifications: true,\n  language: 'en',\n};\n\nconst userPrefs: Partial<Settings> = {\n  theme: 'dark',\n  fontSize: 16,\n};\n\nconst finalSettings = mergeSettings(defaults, userPrefs);\n// { theme: 'dark', fontSize: 16, notifications: true, language: 'en' }\n```\n\n**Why functional is better here**: Spread syntax is concise and handles any number of keys. Later spreads override earlier ones, giving you natural \"defaults with overrides\" behavior.\n\n### Deep Merge: Nested Object Combination\n\n**The Task**: Merge nested configuration objects.\n\n#### Imperative Approach\n\n```typescript\ninterface Config {\n  api: {\n    baseUrl: string;\n    timeout: number;\n    retries: number;\n  };\n  ui: {\n    theme: string;\n    animations: boolean;\n  };\n}\n\nfunction deepMerge(\n  target: Config,\n  source: Partial<Config>\n): Config {\n  const result = { ...target };\n\n  if (source.api) {\n    result.api = { ...target.api, ...source.api };\n  }\n  if (source.ui) {\n    result.ui = { ...target.ui, ...source.ui };\n  }\n\n  return result;\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic deep merge for one level of nesting\nconst deepMerge = <T extends Record<string, object>>(\n  target: T,\n  source: { [K in keyof T]?: Partial<T[K]> }\n): T => {\n  const result = { ...target };\n\n  for (const key of Object.keys(source) as Array<keyof T>) {\n    if (source[key] !== undefined) {\n      result[key] = { ...target[key], ...source[key] };\n    }\n  }\n\n  return result;\n};\n\n// Usage\nconst defaultConfig: Config = {\n  api: { baseUrl: 'https://api.example.com', timeout: 5000, retries: 3 },\n  ui: { theme: 'light', animations: true },\n};\n\nconst customConfig = deepMerge(defaultConfig, {\n  api: { timeout: 10000 },\n  ui: { theme: 'dark' },\n});\n// api.baseUrl preserved, api.timeout overridden\n// ui.theme overridden, ui.animations preserved\n```\n\n### Immutable Updates: Change Nested Values\n\n**The Task**: Update a deeply nested value without mutation.\n\n#### Imperative (Mutating) Approach\n\n```typescript\ninterface State {\n  user: {\n    profile: {\n      settings: {\n        theme: string;\n      };\n    };\n  };\n}\n\nfunction updateTheme(state: State, newTheme: string): void {\n  state.user.profile.settings.theme = newTheme; // Mutation!\n}\n```\n\n#### Functional (Immutable) Approach\n\n```typescript\n// Manual spread nesting\nconst updateTheme = (state: State, newTheme: string): State => ({\n  ...state,\n  user: {\n    ...state.user,\n    profile: {\n      ...state.user.profile,\n      settings: {\n        ...state.user.profile.settings,\n        theme: newTheme,\n      },\n    },\n  },\n});\n\n// With a lens-like helper\nconst updatePath = <T, V>(\n  obj: T,\n  path: string[],\n  value: V\n): T => {\n  if (path.length === 0) return value as unknown as T;\n\n  const [head, ...rest] = path;\n  return {\n    ...obj,\n    [head]: updatePath((obj as Record<string, unknown>)[head], rest, value),\n  } as T;\n};\n\nconst newState = updatePath(state, ['user', 'profile', 'settings', 'theme'], 'dark');\n```\n\n**Honest assessment**: The spread nesting is verbose but explicit. For deeply nested updates, consider using a library like `immer` or fp-ts lenses. The verbosity of the functional approach is the price of immutability.\n\n---\n\n## 3. Data Normalization\n\nAPI responses rarely match the shape your app needs. Normalization transforms nested, denormalized data into flat, indexed structures.\n\n### API Response to App State\n\n**The Task**: Transform a nested API response into a normalized state.\n\n#### API Response (What You Get)\n\n```typescript\ninterface ApiResponse {\n  orders: Array<{\n    id: string;\n    customerId: string;\n    customerName: string;\n    customerEmail: string;\n    items: Array<{\n      productId: string;\n      productName: string;\n      quantity: number;\n      price: number;\n    }>;\n    total: number;\n    status: string;\n  }>;\n}\n```\n\n#### App State (What You Need)\n\n```typescript\ninterface NormalizedState {\n  orders: {\n    byId: Record<string, Order>;\n    allIds: string[];\n  };\n  customers: {\n    byId: Record<string, Customer>;\n    allIds: string[];\n  };\n  products: {\n    byId: Record<string, Product>;\n    allIds: string[];\n  };\n}\n\ninterface Order {\n  id: string;\n  customerId: string;\n  itemIds: string[];\n  total: number;\n  status: string;\n}\n\ninterface Customer {\n  id: string;\n  name: string;\n  email: string;\n}\n\ninterface Product {\n  id: string;\n  name: string;\n  price: number;\n}\n```\n\n#### Imperative Approach\n\n```typescript\nfunction normalizeApiResponse(response: ApiResponse): NormalizedState {\n  const state: NormalizedState = {\n    orders: { byId: {}, allIds: [] },\n    customers: { byId: {}, allIds: [] },\n    products: { byId: {}, allIds: [] },\n  };\n\n  for (const order of response.orders) {\n    // Extract customer\n    if (!state.customers.byId[order.customerId]) {\n      state.customers.byId[order.customerId] = {\n        id: order.customerId,\n        name: order.customerName,\n        email: order.customerEmail,\n      };\n      state.customers.allIds.push(order.customerId);\n    }\n\n    // Extract products and build item IDs\n    const itemIds: string[] = [];\n    for (const item of order.items) {\n      if (!state.products.byId[item.productId]) {\n        state.products.byId[item.productId] = {\n          id: item.productId,\n          name: item.productName,\n          price: item.price,\n        };\n        state.products.allIds.push(item.productId);\n      }\n      itemIds.push(item.productId);\n    }\n\n    // Add normalized order\n    state.orders.byId[order.id] = {\n      id: order.id,\n      customerId: order.customerId,\n      itemIds,\n      total: order.total,\n      status: order.status,\n    };\n    state.orders.allIds.push(order.id);\n  }\n\n  return state;\n}\n```\n\n#### Functional Approach\n\n```typescript\nimport { pipe } from 'fp-ts/function';\nimport * as A from 'fp-ts/Array';\nimport * as R from 'fp-ts/Record';\n\n// Helper to create normalized collection\ninterface NormalizedCollection<T extends { id: string }> {\n  byId: Record<string, T>;\n  allIds: string[];\n}\n\nconst createNormalizedCollection = <T extends { id: string }>(\n  items: T[]\n): NormalizedCollection<T> => ({\n  byId: pipe(\n    items,\n    A.reduce({} as Record<string, T>, (acc, item) => ({\n      ...acc,\n      [item.id]: item,\n    }))\n  ),\n  allIds: items.map(item => item.id),\n});\n\n// Extract entities\nconst extractCustomers = (orders: ApiResponse['orders']): Customer[] =>\n  pipe(\n    orders,\n    A.map(order => ({\n      id: order.customerId,\n      name: order.customerName,\n      email: order.customerEmail,\n    })),\n    A.uniq({ equals: (a, b) => a.id === b.id })\n  );\n\nconst extractProducts = (orders: ApiResponse['orders']): Product[] =>\n  pipe(\n    orders,\n    A.flatMap(order => order.items),\n    A.map(item => ({\n      id: item.productId,\n      name: item.productName,\n      price: item.price,\n    })),\n    A.uniq({ equals: (a, b) => a.id === b.id })\n  );\n\nconst extractOrders = (orders: ApiResponse['orders']): Order[] =>\n  orders.map(order => ({\n    id: order.id,\n    customerId: order.customerId,\n    itemIds: order.items.map(item => item.productId),\n    total: order.total,\n    status: order.status,\n  }));\n\n// Compose into final normalization\nconst normalizeApiResponse = (response: ApiResponse): NormalizedState => ({\n  orders: createNormalizedCollection(extractOrders(response.orders)),\n  customers: createNormalizedCollection(extractCustomers(response.orders)),\n  products: createNormalizedCollection(extractProducts(response.orders)),\n});\n```\n\n**Why functional is better here**: Each extraction is independent and testable. The `createNormalizedCollection` helper is reusable. Adding a new entity type means adding one new extraction function.\n\n### Transform API Response to UI-Ready Data\n\n**The Task**: Convert API data to what your components need.\n\n```typescript\n// API gives you this\ninterface ApiUser {\n  user_id: string;\n  first_name: string;\n  last_name: string;\n  email_address: string;\n  created_at: string; // ISO string\n  avatar_url: string | null;\n}\n\n// Components need this\ninterface DisplayUser {\n  id: string;\n  fullName: string;\n  email: string;\n  memberSince: string; // \"Jan 2024\"\n  avatarUrl: string; // With fallback\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst formatDate = (isoString: string): string => {\n  const date = new Date(isoString);\n  return date.toLocaleDateString('en-US', { month: 'short', year: 'numeric' });\n};\n\nconst DEFAULT_AVATAR = 'https://example.com/default-avatar.png';\n\nconst toDisplayUser = (apiUser: ApiUser): DisplayUser => ({\n  id: apiUser.user_id,\n  fullName: `${apiUser.first_name} ${apiUser.last_name}`,\n  email: apiUser.email_address,\n  memberSince: formatDate(apiUser.created_at),\n  avatarUrl: apiUser.avatar_url ?? DEFAULT_AVATAR,\n});\n\n// Transform array of users\nconst toDisplayUsers = (apiUsers: ApiUser[]): DisplayUser[] =>\n  apiUsers.map(toDisplayUser);\n```\n\n---\n\n## 4. Grouping and Aggregation\n\nGrouping and aggregating data is essential for reports, dashboards, and analytics.\n\n### GroupBy: Organize by Key\n\n**The Task**: Group orders by customer.\n\n#### Imperative Approach\n\n```typescript\ninterface Order {\n  id: string;\n  customerId: string;\n  total: number;\n  date: string;\n}\n\nfunction groupByCustomer(orders: Order[]): Record<string, Order[]> {\n  const result: Record<string, Order[]> = {};\n\n  for (const order of orders) {\n    if (!result[order.customerId]) {\n      result[order.customerId] = [];\n    }\n    result[order.customerId].push(order);\n  }\n\n  return result;\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic groupBy utility\nconst groupBy = <T, K extends string | number>(\n  getKey: (item: T) => K\n) => (items: T[]): Record<K, T[]> =>\n  items.reduce(\n    (groups, item) => {\n      const key = getKey(item);\n      return {\n        ...groups,\n        [key]: [...(groups[key] || []), item],\n      };\n    },\n    {} as Record<K, T[]>\n  );\n\n// Usage\nconst groupByCustomer = groupBy<Order, string>(order => order.customerId);\nconst ordersByCustomer = groupByCustomer(orders);\n\n// Or inline\nconst ordersByStatus = groupBy((order: Order) => order.status)(orders);\n```\n\n**Using fp-ts NonEmptyArray.groupBy**:\n\n```typescript\nimport * as NEA from 'fp-ts/NonEmptyArray';\nimport { pipe } from 'fp-ts/function';\n\n// NEA.groupBy guarantees non-empty arrays in result\nconst ordersByCustomer = pipe(\n  orders as NEA.NonEmptyArray<Order>, // Must be non-empty\n  NEA.groupBy(order => order.customerId)\n); // Record<string, NonEmptyArray<Order>>\n```\n\n### CountBy: Count Occurrences\n\n**The Task**: Count orders by status.\n\n#### Imperative Approach\n\n```typescript\nfunction countByStatus(orders: Order[]): Record<string, number> {\n  const counts: Record<string, number> = {};\n\n  for (const order of orders) {\n    counts[order.status] = (counts[order.status] || 0) + 1;\n  }\n\n  return counts;\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic countBy utility\nconst countBy = <T, K extends string>(\n  getKey: (item: T) => K\n) => (items: T[]): Record<K, number> =>\n  items.reduce(\n    (counts, item) => {\n      const key = getKey(item);\n      return {\n        ...counts,\n        [key]: (counts[key] || 0) + 1,\n      };\n    },\n    {} as Record<K, number>\n  );\n\n// Usage\nconst orderCountByStatus = countBy((order: Order) => order.status)(orders);\n// { pending: 5, shipped: 12, delivered: 8 }\n```\n\n### SumBy: Aggregate Numeric Values\n\n**The Task**: Calculate total revenue per product category.\n\n#### Imperative Approach\n\n```typescript\ninterface Sale {\n  productId: string;\n  category: string;\n  amount: number;\n}\n\nfunction sumByCategory(sales: Sale[]): Record<string, number> {\n  const totals: Record<string, number> = {};\n\n  for (const sale of sales) {\n    totals[sale.category] = (totals[sale.category] || 0) + sale.amount;\n  }\n\n  return totals;\n}\n```\n\n#### Functional Approach\n\n```typescript\n// Generic sumBy utility\nconst sumBy = <T, K extends string>(\n  getKey: (item: T) => K,\n  getValue: (item: T) => number\n) => (items: T[]): Record<K, number> =>\n  items.reduce(\n    (totals, item) => {\n      const key = getKey(item);\n      return {\n        ...totals,\n        [key]: (totals[key] || 0) + getValue(item),\n      };\n    },\n    {} as Record<K, number>\n  );\n\n// Usage\nconst revenueByCategory = sumBy(\n  (sale: Sale) => sale.category,\n  (sale: Sale) => sale.amount\n)(sales);\n// { electronics: 15000, clothing: 8500, books: 3200 }\n```\n\n### Complex Aggregation Example\n\n**The Task**: Calculate totals from line items with quantity and unit price.\n\n```typescript\ninterface LineItem {\n  productId: string;\n  productName: string;\n  quantity: number;\n  unitPrice: number;\n}\n\ninterface Invoice {\n  id: string;\n  lineItems: LineItem[];\n  taxRate: number;\n}\n```\n\n#### Functional Approach\n\n```typescript\nconst lineTotal = (item: LineItem): number =>\n  item.quantity * item.unitPrice;\n\nconst subtotal = (items: LineItem[]): number =>\n  items.reduce((sum, item) => sum + lineTotal(item), 0);\n\nconst calculateTax = (amount: number, rate: number): number =>\n  amount * rate;\n\nconst calculateInvoiceTotal = (invoice: Invoice): {\n  subtotal: number;\n  tax: number;\n  total: number;\n} => {\n  const sub = subtotal(invoice.lineItems);\n  const tax = calculateTax(sub, invoice.taxRate);\n\n  return {\n    subtotal: sub,\n    tax,\n    total: sub + tax,\n  };\n};\n\n// With fp-ts pipe for clarity\nimport { pipe } from 'fp-ts/function';\n\nconst calculateInvoiceTotal = (invoice: Invoice) => {\n  const sub = pipe(\n    invoice.lineItems,\n    A.map(lineTotal),\n    A.reduce(0, (a, b) => a + b)\n  );\n\n  return {\n    subtotal: sub,\n    tax: sub * invoice.taxRate,\n    total: sub * (1 + invoice.taxRate),\n  };\n};\n```\n\n---\n\n## 5. Null-Safe Access\n\nStop writing `if (x && x.y && x.y.z)`. Safely navigate nested structures without runtime errors.\n\n### The Problem\n\n```typescript\ninterface Config {\n  database?: {\n    connection?: {\n      host?: string;\n      port?: number;\n    };\n    pool?: {\n      max?: number;\n    };\n  };\n  features?: {\n    experimental?: {\n      enabled?: boolean;\n    };\n  };\n}\n```\n\n#### Imperative (Verbose) Approach\n\n```typescript\nfunction getDatabaseHost(config: Config): string {\n  if (\n    config.database &&\n    config.database.connection &&\n    config.database.connection.host\n  ) {\n    return config.database.connection.host;\n  }\n  return 'localhost';\n}\n```\n\n#### Optional Chaining (Modern TypeScript)\n\n```typescript\nconst getDatabaseHost = (config: Config): string =>\n  config.database?.connection?.host ?? 'localhost';\n```\n\n**Honest assessment**: For simple access patterns, optional chaining (`?.`) is perfect. It's built into the language and very readable. Use fp-ts Option when you need to compose operations on potentially missing values.\n\n### When to Use Option Instead\n\nUse fp-ts Option when:\n- You need to chain multiple operations on potentially missing values\n- You want to distinguish \"missing\" from other falsy values\n- You're building a pipeline of transformations\n\n```typescript\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\n// Safe property access that returns Option\nconst prop = <T, K extends keyof T>(key: K) =>\n  (obj: T | null | undefined): O.Option<T[K]> =>\n    obj != null && key in obj\n      ? O.some(obj[key] as T[K])\n      : O.none;\n\n// Chain accesses with flatMap\nconst getDatabaseHost = (config: Config): O.Option<string> =>\n  pipe(\n    O.some(config),\n    O.flatMap(prop('database')),\n    O.flatMap(prop('connection')),\n    O.flatMap(prop('host'))\n  );\n\n// Extract with default\nconst host = pipe(\n  getDatabaseHost(config),\n  O.getOrElse(() => 'localhost')\n);\n```\n\n### Safe Array Access\n\n```typescript\nimport * as A from 'fp-ts/Array';\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\n// Imperative: throws if array is empty\nconst first = items[0]; // Could be undefined!\n\n// Safe: returns Option\nconst first = A.head(items); // Option<Item>\n\n// Get first item's name, or default\nconst firstName = pipe(\n  items,\n  A.head,\n  O.map(item => item.name),\n  O.getOrElse(() => 'No items')\n);\n\n// Safe lookup by index\nconst third = pipe(\n  items,\n  A.lookup(2),\n  O.map(item => item.name),\n  O.getOrElse(() => 'Not found')\n);\n```\n\n### Safe Record/Dictionary Access\n\n```typescript\nimport * as R from 'fp-ts/Record';\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\nconst users: Record<string, User> = {\n  'user-1': { name: 'Alice', email: 'alice@example.com' },\n  'user-2': { name: 'Bob', email: 'bob@example.com' },\n};\n\n// Imperative: could be undefined\nconst user = users['user-3']; // User | undefined\n\n// Safe: returns Option\nconst user = R.lookup('user-3')(users); // Option<User>\n\n// Get user email or default\nconst email = pipe(\n  users,\n  R.lookup('user-3'),\n  O.map(u => u.email),\n  O.getOrElse(() => 'unknown@example.com')\n);\n```\n\n### Combining Multiple Optional Values\n\n**The Task**: Get a user's display name, which requires both first and last name.\n\n```typescript\ninterface Profile {\n  firstName?: string;\n  lastName?: string;\n  nickname?: string;\n}\n\n// Imperative\nfunction getDisplayName(profile: Profile): string {\n  if (profile.firstName && profile.lastName) {\n    return `${profile.firstName} ${profile.lastName}`;\n  }\n  if (profile.nickname) {\n    return profile.nickname;\n  }\n  return 'Anonymous';\n}\n\n// Functional with Option\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\nconst getDisplayName = (profile: Profile): string =>\n  pipe(\n    // Try full name first\n    O.Do,\n    O.bind('first', () => O.fromNullable(profile.firstName)),\n    O.bind('last', () => O.fromNullable(profile.lastName)),\n    O.map(({ first, last }) => `${first} ${last}`),\n    // Fall back to nickname\n    O.alt(() => O.fromNullable(profile.nickname)),\n    // Finally, default to Anonymous\n    O.getOrElse(() => 'Anonymous')\n  );\n```\n\n---\n\n## 6. Real-World Examples\n\n### Example 1: Transform API Response to UI-Ready Data\n\n```typescript\n// API response\ninterface ApiOrder {\n  order_id: string;\n  customer: {\n    id: string;\n    full_name: string;\n  };\n  line_items: Array<{\n    product_id: string;\n    product_name: string;\n    qty: number;\n    unit_price: number;\n  }>;\n  order_date: string;\n  status: 'pending' | 'processing' | 'shipped' | 'delivered';\n}\n\n// What the UI needs\ninterface OrderSummary {\n  id: string;\n  customerName: string;\n  itemCount: number;\n  total: number;\n  formattedTotal: string;\n  date: string;\n  statusLabel: string;\n  statusColor: string;\n}\n\n// Transformation\nconst STATUS_CONFIG: Record<string, { label: string; color: string }> = {\n  pending: { label: 'Pending', color: 'yellow' },\n  processing: { label: 'Processing', color: 'blue' },\n  shipped: { label: 'Shipped', color: 'purple' },\n  delivered: { label: 'Delivered', color: 'green' },\n};\n\nconst formatCurrency = (cents: number): string =>\n  `$${(cents / 100).toFixed(2)}`;\n\nconst formatDate = (iso: string): string =>\n  new Date(iso).toLocaleDateString('en-US', {\n    month: 'short',\n    day: 'numeric',\n    year: 'numeric',\n  });\n\nconst toOrderSummary = (order: ApiOrder): OrderSummary => {\n  const total = order.line_items.reduce(\n    (sum, item) => sum + item.qty * item.unit_price,\n    0\n  );\n\n  const status = STATUS_CONFIG[order.status] ?? STATUS_CONFIG.pending;\n\n  return {\n    id: order.order_id,\n    customerName: order.customer.full_name,\n    itemCount: order.line_items.reduce((sum, item) => sum + item.qty, 0),\n    total,\n    formattedTotal: formatCurrency(total),\n    date: formatDate(order.order_date),\n    statusLabel: status.label,\n    statusColor: status.color,\n  };\n};\n\n// Transform all orders\nconst toOrderSummaries = (orders: ApiOrder[]): OrderSummary[] =>\n  orders.map(toOrderSummary);\n```\n\n### Example 2: Merge User Settings with Defaults\n\n```typescript\ninterface AppSettings {\n  theme: {\n    mode: 'light' | 'dark' | 'system';\n    primaryColor: string;\n    fontSize: 'small' | 'medium' | 'large';\n  };\n  notifications: {\n    email: boolean;\n    push: boolean;\n    sms: boolean;\n    frequency: 'immediate' | 'daily' | 'weekly';\n  };\n  privacy: {\n    showProfile: boolean;\n    showActivity: boolean;\n    allowAnalytics: boolean;\n  };\n}\n\ntype DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];\n};\n\nconst DEFAULT_SETTINGS: AppSettings = {\n  theme: {\n    mode: 'system',\n    primaryColor: '#007bff',\n    fontSize: 'medium',\n  },\n  notifications: {\n    email: true,\n    push: true,\n    sms: false,\n    frequency: 'immediate',\n  },\n  privacy: {\n    showProfile: true,\n    showActivity: true,\n    allowAnalytics: true,\n  },\n};\n\nconst deepMergeSettings = (\n  defaults: AppSettings,\n  user: DeepPartial<AppSettings>\n): AppSettings => ({\n  theme: { ...defaults.theme, ...user.theme },\n  notifications: { ...defaults.notifications, ...user.notifications },\n  privacy: { ...defaults.privacy, ...user.privacy },\n});\n\n// Usage\nconst userPreferences: DeepPartial<AppSettings> = {\n  theme: { mode: 'dark' },\n  notifications: { sms: true, frequency: 'daily' },\n};\n\nconst finalSettings = deepMergeSettings(DEFAULT_SETTINGS, userPreferences);\n```\n\n### Example 3: Group Orders by Customer with Totals\n\n```typescript\ninterface Order {\n  id: string;\n  customerId: string;\n  customerName: string;\n  items: Array<{ name: string; price: number; quantity: number }>;\n  date: string;\n}\n\ninterface CustomerOrderSummary {\n  customerId: string;\n  customerName: string;\n  orderCount: number;\n  totalSpent: number;\n  orders: Order[];\n}\n\nconst calculateOrderTotal = (order: Order): number =>\n  order.items.reduce((sum, item) => sum + item.price * item.quantity, 0);\n\nconst groupOrdersByCustomer = (orders: Order[]): CustomerOrderSummary[] => {\n  const grouped = groupBy((order: Order) => order.customerId)(orders);\n\n  return Object.entries(grouped).map(([customerId, customerOrders]) => ({\n    customerId,\n    customerName: customerOrders[0].customerName,\n    orderCount: customerOrders.length,\n    totalSpent: customerOrders.reduce(\n      (sum, order) => sum + calculateOrderTotal(order),\n      0\n    ),\n    orders: customerOrders,\n  }));\n};\n```\n\n### Example 4: Safely Access Deeply Nested Config\n\n```typescript\ninterface AppConfig {\n  services?: {\n    api?: {\n      endpoints?: {\n        users?: string;\n        orders?: string;\n        products?: string;\n      };\n      auth?: {\n        type?: 'bearer' | 'basic' | 'oauth';\n        token?: string;\n      };\n    };\n    database?: {\n      primary?: {\n        host?: string;\n        port?: number;\n        name?: string;\n      };\n    };\n  };\n}\n\nimport * as O from 'fp-ts/Option';\nimport { pipe } from 'fp-ts/function';\n\n// Create a type-safe config accessor\nconst getConfigValue = <T>(\n  config: AppConfig,\n  path: (config: AppConfig) => T | undefined,\n  defaultValue: T\n): T => path(config) ?? defaultValue;\n\n// Usage with optional chaining (simplest)\nconst apiUsersEndpoint = getConfigValue(\n  config,\n  c => c.services?.api?.endpoints?.users,\n  '/api/users'\n);\n\n// For more complex scenarios, use Option\nconst getEndpoint = (config: AppConfig, name: 'users' | 'orders' | 'products'): string =>\n  pipe(\n    O.fromNullable(config.services),\n    O.flatMap(s => O.fromNullable(s.api)),\n    O.flatMap(a => O.fromNullable(a.endpoints)),\n    O.flatMap(e => O.fromNullable(e[name])),\n    O.getOrElse(() => `/api/${name}`)\n  );\n\n// Reusable pattern for multiple values\nconst getDbConfig = (config: AppConfig) => ({\n  host: config.services?.database?.primary?.host ?? 'localhost',\n  port: config.services?.database?.primary?.port ?? 5432,\n  name: config.services?.database?.primary?.name ?? 'app',\n});\n```\n\n---\n\n## 7. When to Use What\n\n### Use Native Methods When:\n\n- **Simple transformations**: `.map()`, `.filter()`, `.reduce()` are perfectly good\n- **No composition needed**: You're doing a one-off transformation\n- **Team familiarity**: Everyone knows native methods\n- **Optional chaining suffices**: `obj?.prop?.value ?? default` handles your null-safety needs\n\n```typescript\n// Native is fine here\nconst activeUserNames = users\n  .filter(u => u.isActive)\n  .map(u => u.name);\n```\n\n### Use fp-ts When:\n\n- **Chaining operations that might fail**: Multiple steps where each can return nothing\n- **Composing transformations**: Building reusable transformation pipelines\n- **Type-safe error handling**: You want the compiler to track potential failures\n- **Complex data pipelines**: Many steps that benefit from explicit composition\n\n```typescript\n// fp-ts shines here\nconst result = pipe(\n  users,\n  A.findFirst(u => u.id === userId),\n  O.flatMap(u => O.fromNullable(u.profile)),\n  O.flatMap(p => O.fromNullable(p.settings)),\n  O.map(s => s.theme),\n  O.getOrElse(() => 'default')\n);\n```\n\n### Use Custom Utilities When:\n\n- **Domain-specific operations**: `groupBy`, `countBy`, `sumBy` for your data\n- **Repeated patterns**: You find yourself writing the same transformation many times\n- **Team conventions**: Establishing consistent patterns across the codebase\n\n```typescript\n// Custom utility pays off when used repeatedly\nconst revenueByRegion = sumBy(\n  (sale: Sale) => sale.region,\n  (sale: Sale) => sale.amount\n)(sales);\n```\n\n### Performance Considerations\n\n- **Chaining creates intermediate arrays**: `arr.filter().map()` creates one array, then another\n- **For hot paths, consider `reduce`**: One pass through the data\n- **Measure before optimizing**: The readability cost of optimization is often not worth it\n\n```typescript\n// If performance matters (and you've measured!)\nconst result = items.reduce((acc, item) => {\n  if (item.isActive) {\n    acc.push(item.name.toUpperCase());\n  }\n  return acc;\n}, [] as string[]);\n\n// vs the more readable (but 2-pass) version\nconst result = items\n  .filter(item => item.isActive)\n  .map(item => item.name.toUpperCase());\n```\n\n---\n\n## Summary\n\n| Task | Imperative | Functional | Recommendation |\n|------|-----------|------------|----------------|\n| Transform array elements | for loop with push | `.map()` | Use map |\n| Filter array | for loop with condition | `.filter()` | Use filter |\n| Accumulate values | for loop with accumulator | `.reduce()` | Use reduce for complex, loop for simple |\n| Group by key | for loop with object | `groupBy` utility | Create reusable utility |\n| Pick object fields | manual property copy | `pick` utility | Use spread for one-off, utility for repeated |\n| Merge objects | property-by-property | spread syntax | Use spread |\n| Deep merge | nested conditionals | recursive utility | Use utility or library |\n| Null-safe access | `if (x && x.y)` | `?.` or Option | Use `?.` for simple, Option for composition |\n| Normalize API data | nested loops | extraction functions | Break into composable functions |\n\n**The functional approach is better when:**\n- You need to compose operations\n- You want reusable transformations\n- You value explicit data flow over implicit state\n- Type safety for missing values matters\n\n**The imperative approach is acceptable when:**\n- The transformation is a one-off\n- The logic is simple and linear\n- Performance is critical and you've measured\n- The team is more comfortable with it\n\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.","tags":["data","transforms","antigravity","awesome","skills","sickn33","agent-skills","agentic-skills","ai-agent-skills","ai-agents","ai-coding","ai-workflows"],"capabilities":["skill","source-sickn33","skill-fp-data-transforms","topic-agent-skills","topic-agentic-skills","topic-ai-agent-skills","topic-ai-agents","topic-ai-coding","topic-ai-workflows","topic-antigravity","topic-antigravity-skills","topic-claude-code","topic-claude-code-skills","topic-codex-cli","topic-codex-skills"],"categories":["antigravity-awesome-skills"],"synonyms":[],"warnings":[],"endpointUrl":"https://skills.sh/sickn33/antigravity-awesome-skills/fp-data-transforms","protocol":"skill","transport":"skills-sh","auth":{"type":"none","details":{"cli":"npx skills add sickn33/antigravity-awesome-skills","source_repo":"https://github.com/sickn33/antigravity-awesome-skills","install_from":"skills.sh"}},"qualityScore":"0.700","qualityRationale":"deterministic score 0.70 from registry signals: · indexed on github topic:agent-skills · 34793 github stars · SKILL.md body (36,543 chars)","verified":false,"liveness":"unknown","lastLivenessCheck":null,"agentReviews":{"count":0,"score_avg":null,"cost_usd_avg":null,"success_rate":null,"latency_p50_ms":null,"narrative_summary":null,"summary_updated_at":null},"enrichmentModel":"deterministic:skill-github:v1","enrichmentVersion":1,"enrichedAt":"2026-04-24T00:50:57.841Z","embedding":null,"createdAt":"2026-04-18T21:37:24.468Z","updatedAt":"2026-04-24T00:50:57.841Z","lastSeenAt":"2026-04-24T00:50:57.841Z","tsv":"'-1':2821 '-2':2827 '-3':2840,2850,2864 '/api':3477 '/api/users':3444 '/array':708,1687,2717 '/default-avatar.png'';':1948 '/function':723,1679,2131,2460,2640,2732,2814,2933,3407 '/nonemptyarray':2124 '/option':716,2633,2725,2807,2926,3400 '/record':1695,2799 '0':232,426,451,478,1388,2190,2227,2291,2332,2411,2472,2742,3115,3135,3323,3345,3356 '007bff':3220 '1':114,117,175,731,736,2191,2228,2485,2977 '100':239,265,3080 '10000':1299 '12':2244 '14':1123 '14.99':247,271 '1499':218,256 '15000':2351 '16':1134,1143 '2':121,124,732,756,805,2781,3082,3159,3753 '2024':1916 '29.99':248,272 '2999':219,257 '3':128,131,733,792,1287,1457,3274 '3200':2355 '4':135,139,1985,3360 '49.99':249,273 '4999':220,258 '5':144,149,2242,2487 '5000':1285 '5432':3499 '6':154,159,2971 '7':164,169,3506 '8':2246 '8500':2353 '9.99':246,270 '999':217,255 'a.endpoints':3470 'a.findfirst':766,3623 'a.flatmap':1771 'a.head':734,742,2751,2765 'a.id':1761,1786 'a.localecompare':569,595,629 'a.lookup':755,2780 'a.map':1749,1774,2469 'a.partition':780 'a.reduce':1725,2471 'a.takeleft':791 'a.uniq':799,1757,1782 'abc123':769 'acc':1730,1732,3738,3745 'acc.push':3742 'accept':3911 'access':19,45,92,148,153,2491,2558,2643,2676,2708,2790,3362,3855 'accessor':3414 'accumul':393,501,3789,3794 'across':929,3670 'activ':312,528,670,777 'activeus':357,366 'activeusernam':3559 'actual':488 'ad':676,1845,1851 'add':1652 'addit':693 'address':1891,1964 'aggreg':14,93,138,143,1988,1991,2248,2357 'alic':2823 'alice@example.com':2825 'allid':1539,1546,1553,1596,1599,1602,1711,1735 'allowanalyt':3195,3237 'alltag':798 'alphabet':532,623,644 'amount':2268,2414,2419 'analyt':1999 'anim':1201,1291 'anonym':2915,2968,2970 'anoth':3703 'api':39,87,1191,1281,1297,1460,1478,1488,1494,1857,1867,1875,2979,2987,3370,3441,3868 'api.baseurl':1303 'api.example.com':1283 'api.timeout':1305 'apiord':2990,3104,3154 'apirespons':1501,1589,1744,1766,1791,1815 'apius':1880,1951,1952,1980,1981 'apiuser.avatar':1970 'apiuser.created':1967 'apiuser.email':1963 'apiuser.first':1958 'apiuser.last':1960 'apiuser.user':1955 'apiusers.map':1983 'apiusersendpoint':3436 'app':1467,1481,1526,3505 'appconfig':3368,3418,3421,3454,3487 'approach':53,65,213,251,318,348,409,438,534,574,839,871,954,972,1028,1063,1105,1187,1226,1327,1348,1451,1584,1671,1922,2011,2052,2167,2195,2260,2296,2391,2525,3880,3909 'appset':3167,3215,3242,3245 'arr.filter':3697 'array':11,35,74,115,119,176,178,205,302,687,694,1264,1503,1513,1975,2137,2707,2736,3002,3291,3696,3701,3771,3781 'array-oper':118 'ask':3973 'assess':61,480,1019,1423,2555 'auth':3378 'avatar':1898,1945,1973 'avatarurl':1917,1969 'b':475,477,568,570,594,596,626,630,752,802,804,1760,1785,2474,2476 'b.id':1762,1787 'back':2959 'baseurl':1192,1282 'basic':3381 'bearer':3380 'behavior':1174 'benefit':514,3609 'better':277,373,648,697,922,1151,1832,3882 'blue':3063 'bob':2829 'bob@example.com':2831 'book':2354 'boolean':327,354,543,607,613,1073,1202,2522,3181,3183,3185,3192,3194,3196 'boundari':3981 'bread':182 'break':453,3874 'build':303,1626,2620,3586 'built':2566 'butter':184 'byid':1535,1542,1549,1595,1598,1601,1707,1722 'c':753,758,3439 'c.services':3440 'calcul':399,458,2253,2361 'calculateinvoicetot':2422,2462 'calculateordertot':3313,3354 'calculatetax':2413,2437 'calculatetot':420,441,467 'cart':407 'cartitem':412,422,443,462,469 'categori':2258,2266 'cent':209,261,264,3076,3079 'chain':518,654,2541,2561,2602,2675,3433,3541,3572,3693 'chainabl':195 'chang':1313 'clarif':3975 'clariti':2453 'clear':283,3948 'cloth':2352 'codebas':931,3672 'collect':1700 'color':3052,3057,3062,3067,3072 'combin':519,1053,1179,2870 'comfort':3937 'compil':3598 'complex':511,2356,3447,3603,3799 'compon':1872,1902 'compos':389,499,1050,1808,2582,3584,3876,3887 'composit':698,3524,3612,3866 'concis':1156 'condit':3785,3845 'config':1190,1206,1209,1280,2509,2529,2530,2547,2548,2681,2682,2686,2703,3047,3119,3365,3413,3417,3420,3428,3438,3453,3486 'config.database':2533,2550 'config.database.connection':2534 'config.database.connection.host':2535,2537 'config.services':3462,3489,3495,3501 'configur':1184 'connect':2511,2551,2692 'consid':1435,3707 'consider':3692 'consist':3668 'const':215,226,242,253,259,266,333,337,350,356,365,428,440,459,466,552,556,576,603,609,616,622,631,728,737,748,762,775,787,795,876,905,915,964,977,993,997,1010,1107,1117,1128,1135,1210,1236,1254,1258,1278,1293,1353,1375,1395,1413,1591,1604,1629,1633,1713,1741,1763,1788,1812,1924,1929,1943,1949,1978,2030,2036,2057,2076,2091,2098,2104,2140,2176,2182,2200,2218,2234,2277,2283,2301,2323,2340,2393,2400,2412,2421,2431,2435,2461,2465,2545,2647,2679,2699,2739,2749,2761,2776,2815,2836,2846,2858,2934,3045,3074,3083,3101,3106,3116,3151,3212,3239,3256,3267,3312,3324,3329,3415,3435,3451,3484,3558,3619,3681,3735,3756 'constant':811 'content':113 'convent':3666 'convert':203,1866 'converttodollar':222,244 'copi':3820 'cost':3719 'could':2743,2833 'count':2158,2162,2177,2186,2188,2193,2216,2223,2225 'countbi':2157,2198,2201,2236,3649 'countbystatus':2170 'cover':25 'creat':1698,1893,3408,3694,3699,3812 'createnormalizedcollect':1714,1818,1822,1826,1841 'criteria':3984 'critic':3928 'custom':1541,1545,1568,1597,1609,1746,1821,2009,2994,3278,3641,3674 'customconfig':1294 'customeremail':1510 'customerid':1506,1559,1659,1798,2017,3286,3302,3340,3342 'customernam':1508,3030,3126,3288,3304,3343,3346 'customerord':3341,3344,3358 'customerorders.length':3348 'customerorders.reduce':3350 'customerordersummari':3301,3328 'd':754 'daili':3188,3266 'dark':1069,1132,1141,1302,1421,3171,3261 'dashboard':1997 'data':3,6,21,27,42,77,103,129,133,186,816,1458,1473,1863,1868,1992,2985,3604,3653,3713,3869,3896 'data-norm':132 'databas':2510,2689,3385,3490,3496,3502 'date':1930,1932,2021,3015,3038,3089,3140,3143,3298 'date.tolocaledatestring':1935 'day':32,3097 'deep':1175,1229,3842 'deepli':1320,1432,3363 'deepmerg':1204,1237,1295 'deepmergeset':3240,3269 'deepparti':3198,3207,3244,3258 'default':1061,1078,1109,1114,1118,1138,1171,1944,1972,2698,2760,2857,2966,3164,3213,3241,3270,3546,3639 'defaultconfig':1279,1296 'defaults.fontsize':1093 'defaults.language':1103 'defaults.notifications':1098,3250 'defaults.privacy':3253 'defaults.theme':1088,3247 'defaultvalu':3424,3429 'delet':1001 'deliv':2245,3021,3069,3071 'denorm':1472 'describ':3952 'destructur':1025 'display':2880 'displayus':1906,1953,1982 'distinguish':2612 'dollar':211,243,267 'domain':3645 'domain-specif':3644 'e':3472,3474 'earlier':1166 'electron':2350 'element':200,288,727,786,3772 'email':847,861,868,911,914,1573,1619,1755,1890,1911,1962,2824,2830,2855,2859,3180,3224 'empti':2136,2150,2738 'en':1127,1147,1937,3093 'en-us':1936,3092 'enabl':2521 'endpoint':3371,3442 'enough':512 'ensur':934 'entiti':1740,1848 'environ':3964 'environment-specif':3963 'equal':800,1758,1783 'equival':58 'error':2504,3593 'essenti':1994 'establish':3667 'everi':31,199 'everyday':5,102 'everyon':3536 'exampl':158,163,2358,2975,2976,3158,3273,3359 'example.com':1947 'example.com/default-avatar.png'';':1946 'exist':941 'experiment':2520 'expert':3969 'explicit':1430,3611,3895 'express':194 'extend':879,882,980,983,1239,1704,1716,2061,2204,2305,2651,3205 'extract':829,1608,1623,1739,1835,1854,2696,3872 'extractcustom':1742,1823 'extractord':1789,1819 'extractproduct':1764,1827 'fail':3576 'failur':3602 'fall':2958 'fallback':1920 'fals':3229 'falsi':2616 'familiar':3535 'featur':2519 'field':813,826,833,945,950,3817 'filter':304,582,585,637,639,669,671,3518,3561,3759,3780,3786,3788 'final':1810,2965 'finalset':1136,3268 'find':759,3657 'fine':1031,3556 'first':54,726,729,784,1884,2740,2750,2755,2885,2943,2946,2954,2956 'firstnam':2762,2892 'firstofempti':738 'flat':1475 'flatmap':2678 'flow':3897 'fontsiz':1070,1089,1122,1133,1142,3175,3221 'formatcurr':3075,3138 'formatd':1925,1966,3084,3141 'formattedtot':3036,3137 'found':763,2787 'fp':2,685,690,706,714,721,1443,1677,1685,1693,2113,2122,2129,2449,2458,2575,2595,2631,2638,2715,2723,2730,2797,2805,2812,2924,2931,3398,3405,3569,3615 'fp-data-transform':1 'fp-ts':684,689,705,713,720,1442,1676,1684,1692,2112,2121,2128,2448,2457,2574,2594,2630,2637,2714,2722,2729,2796,2804,2811,2923,2930,3397,3404,3568,3614 'free':545 'frequenc':3186,3230,3265 'full':2941,2997 'fullnam':1909,1957 'function':9,57,99,221,250,275,328,347,371,419,437,492,547,573,646,853,870,920,956,971,1036,1076,1104,1149,1203,1225,1336,1346,1450,1586,1670,1830,1855,1921,2023,2051,2169,2194,2270,2295,2390,2527,2899,2916,3768,3873,3877,3879 'generic':873,974,1228,2054,2197,2298 'get':310,523,673,1498,2754,2853,2876 'getactivepremiumnam':548,577,632 'getactiveus':329 'getconfigvalu':3416,3437 'getdatabasehost':2528,2546,2680,2702 'getdbconfig':3485 'getdisplaynam':2900,2935 'getendpoint':3452 'getkey':2064,2078,2206,2220,2307,2325 'getnam':617,642 'getpublicus':854,906,917 'getvalu':2311,2333 'give':1168,1876 'good':3522 'green':3073 'group':13,41,76,136,141,774,1986,1989,2006,2074,2081,2083,3275,3330,3338,3803 'groupbi':2000,2055,2058,2093,2106,3331,3648,3810 'groupbycustom':2024,2092,2100 'grouping-and-aggreg':140 'groupordersbycustom':3325 'guarante':2133 'handl':1158,3547,3594 'head':725,1396,1401,1408 'helper':1374,1696,1842 'honest':60,479,1018,1422,2554 'host':2512,2552,2695,2700,3387,3488,3492 'hot':3705 'id':322,538,843,857,864,909,912,1504,1557,1569,1577,1615,1628,1642,1657,1705,1717,1751,1776,1796,1882,1907,1954,1956,2015,2384,2992,2995,3004,3028,3123,3125,3284 'immedi':282,3187,3231 'immer':1440 'immut':1311,1347,1456 'imper':52,212,317,408,485,533,838,953,1027,1062,1186,1325,1583,2010,2166,2259,2523,2733,2832,2898,3767,3908 'implicit':3899 'import':701,709,717,1673,1680,1688,2117,2125,2454,2626,2634,2710,2718,2726,2792,2800,2808,2919,2927,3393,3401 'inact':776 'independ':391,1837 'index':298,747,1476,2775 'inlin':361,2103 'input':3978 'instead':105,2592 'intent':280 'interfac':320,411,536,841,1065,1189,1329,1500,1532,1555,1567,1575,1701,1879,1905,2013,2262,2372,2382,2508,2890,2989,3026,3166,3282,3300,3367 'intermedi':3695 'internalnot':851,963,966,1015,1017 'invoic':2383,2423,2424,2463,2464 'invoice.lineitems':2434,2468 'invoice.taxrate':2439,2482,2486 'involv':85 'isact':326,351,359,377,542,604,638 'iso':1896,3085,3090 'isostr':1926,1933 'ispremium':610,640 'item':404,421,429,431,442,447,461,468,1512,1627,1634,1719,1724,1731,1734,1737,1775,1802,2065,2068,2075,2079,2085,2207,2210,2217,2221,2308,2312,2315,2322,2326,2334,2365,2395,2402,2407,2410,2741,2752,2756,2764,2767,2771,2779,2783,3001,3110,3132,3290,3319,3739,3758,3760,3763 'item.id':1733,1738 'item.isactive':3741,3761 'item.name':2768,2784 'item.name.touppercase':3743,3764 'item.price':433,449,464,1647,1781,3321 'item.productid':1639,1641,1643,1649,1651,1777,1803 'item.productname':1645,1779 'item.qty':3112,3134 'item.quantity':434,450,465,2398,3322 'item.unit':3113 'item.unitprice':2399 'itemcount':3032,3129 'itemid':1561,1630,1661,1800 'itemids.push':1650 'items.map':471,1736 'items.reduce':445,2073,2215,2320,2405,3737 'iter':382 'jan':1915 'k':881,886,891,904,982,987,992,1009,1246,1252,2060,2067,2071,2088,2203,2209,2213,2231,2304,2310,2318,2337,2650,2655,2662,2673 'keep':305 'key':885,894,896,898,939,986,998,1000,1003,1162,1259,1267,1270,1272,1274,2003,2077,2082,2084,2219,2224,2226,2324,2329,2331,2654,2665,2670,3805 'keyof':883,984,1248,2652,3201 'keys.reduce':892 'know':3537 'label':3050,3055,3060,3065,3070 'languag':1074,1099,1126,1146,2569 'larg':3178 'last':1887,2887,2950,2955,2957 'lastnam':2894 'later':1163 'len':1372 'lens':1445 'lens-lik':1371 'let':188,230,424 'level':109,1233 'librari':1438,3851 'light':1068,1121,1290,3170 'like':1373,1439 'limit':3940 'line':456,2364,3000 'linear':3925 'lineitem':2373,2386,2387,2396,2403 'linetot':460,472,2394,2409,2470 'list':316 'localhost':2539,2553,2705,3493 'log':952 'logic':291,383,509,3921 'lookup':745,2773 'loop':110,192,486,3774,3783,3792,3800,3807,3871 'low':108 'low-level':107 'manag':299 'mani':1044,3606,3663 'manual':301,1350,3818 'map':197,284,589,641,3339,3517,3564,3698,3762,3777,3779 'match':307,1463,3949 'matter':3730,3906 'max':2517 'mean':1850 'measur':3714,3734,3932 'medium':3177,3222 'membersinc':1913,1965 'merg':817,1052,1057,1176,1182,1230,3160,3832,3843 'mergeset':1077,1108,1137 'method':3513,3539 'might':3575 'miss':2586,2607,2613,3904,3986 'mode':3169,3217,3260 'modern':2542 'modul':688 'month':1939,3095 'multipl':2603,2871,3482,3577 'must':2146 'mutat':1324,1326,1345 'n':785 'name':294,324,413,517,525,540,599,674,845,859,866,910,913,1571,1579,1617,1644,1753,1778,1885,1888,1959,1961,2758,2822,2828,2881,2888,2942,2998,3007,3128,3292,3391,3455,3475,3478,3500,3504 'nativ':3512,3538,3554 'natur':1170 'navig':2499 'nea':2119 'nea.groupby':2132,2151 'nea.nonemptyarray':2145 'need':71,497,809,1048,1468,1530,1873,1903,2580,2600,3025,3525,3552,3885 'nest':46,79,821,1177,1183,1235,1314,1321,1352,1426,1433,1471,1487,2500,3364,3844,3870 'new':396,1847,1853,1931,3088 'newstat':1414 'newthem':1340,1344,1357,1368 'nicknam':2896,2961 'non':2135,2149 'non-empti':2134,2148 'none':743 'nonemptyarray':2156 'nonemptyarray.groupby':2115 'normal':38,95,130,134,1459,1469,1492,1653,1699,1811,3867 'normalizeapirespons':1587,1813 'normalizedcollect':1702,1721 'normalizedst':1533,1590,1593,1816 'noth':3583 'notif':1072,1094,1124,1144,3179,3223,3249,3262 'null':17,90,146,151,1901,2489,2658,2664,3550,3853 'null-saf':16,89,145,2488,3852 'null-safe-access':150 'null-safeti':3549 'number':224,225,228,262,263,416,418,423,444,463,470,628,741,1071,1160,1195,1197,1519,1521,1523,1564,1582,2020,2063,2175,2180,2214,2232,2269,2276,2281,2314,2319,2338,2379,2381,2389,2397,2404,2415,2417,2418,2426,2428,2430,2515,2518,3010,3013,3033,3035,3077,3295,3297,3307,3309,3316,3390 'numer':1942,2249,3098,3100 'o':711,2628,2720,2802,2921,3395 'o.alt':2962 'o.bind':2945,2949 'o.do':2944 'o.flatmap':2687,2690,2693,3463,3467,3471,3627,3631 'o.fromnullable':2947,2951,2963,3461,3465,3469,3473,3629,3633 'o.getorelse':2704,2769,2785,2868,2969,3476,3638 'o.map':2766,2782,2865,2953,3635 'o.none':2674 'o.option':2660,2683 'o.some':2668,2685 'oauth':3382 'obj':887,897,988,995,1379,1400,1403,2656,2663,2667,2669,3543 'object':12,37,75,122,126,806,808,837,880,981,1054,1178,1185,1242,3206,3809,3816,3833 'object-transform':125 'object.entries':3337 'object.keys':1261 'occurr':2159 'often':3723 'omit':814,942,960,975,978,990,1007,1012,1024,1037 'one':1022,1167,1232,1852,3531,3700,3709,3827,3918 'one-off':1021,3530,3826,3917 'oper':116,120,177,179,196,520,2583,2604,3573,3647,3888 'optim':3716,3721 'option':770,2540,2560,2577,2591,2597,2646,2748,2753,2845,2852,2872,2918,3432,3450,3540,3860,3864 'order':1502,1534,1538,1556,1594,1605,1654,1743,1745,1748,1750,1765,1767,1770,1772,1790,1792,1793,1795,1817,2007,2014,2025,2026,2029,2034,2037,2039,2048,2094,2096,2101,2107,2108,2110,2143,2152,2163,2171,2172,2183,2185,2237,2238,2240,2991,3014,3103,3150,3153,3276,3283,3310,3311,3314,3315,3326,3327,3332,3333,3335,3352,3355,3357,3374,3457 'order.customer.full':3127 'order.customeremail':1620,1756 'order.customerid':1612,1614,1616,1622,1660,1752,1799,2042,2044,2046,2097,2153,3334 'order.customername':1618,1754 'order.id':1656,1658,1667,1797 'order.items':1636,1773 'order.items.map':1801 'order.items.reduce':3317 'order.line_items.reduce':3108,3130 'order.order':3124,3142 'order.status':1665,1807,2109,2187,2189,2239,3120 'order.total':1663,1805 'ordercount':3306,3347 'ordercountbystatus':2235 'orders.map':1794,3156 'ordersbycustom':2099,2141 'ordersbystatus':2105 'ordersummari':3027,3105,3155 'organ':2001 'output':3958 'overrid':1165,1173 'overridden':1306,1308 'p':3199,3204,3209,3211,3632 'p.settings':3634 'partial':1081,1112,1130,1208,1250 'partit':771 'pass':3710,3754 'passwordhash':849,962,965,1014,1016 'path':1381,1398,3419,3427,3706 'path.length':1387 'pattern':10,100,2559,3480,3655,3669 'pay':1039,3676 'pend':2241,3018,3054,3056 'per':2256 'perfect':1030,2563,3521 'perform':3691,3729,3926 'permiss':3979 'pick':812,823,874,877,889,902,907,925,938,3815,3821 'pipe':718,730,739,750,764,778,789,797,1674,1723,1747,1769,2126,2142,2451,2455,2467,2635,2684,2701,2727,2763,2778,2809,2860,2928,2939,3402,3460,3621 'pipelin':2622,3589,3605 'pool':2516 'port':2514,3389,3494,3498 'potenti':2585,2606,3601 'practic':20,98 'predic':364,376,390,600,761 'premium':529,546,563,588,615,672 'preserv':1304,1310 'price':207,223,237,402,415,1454,1520,1581,1646,1780,2370,3012,3114,3294 'prices.length':234 'pricesinc':216,245,254 'pricesincents.map':268 'primari':3386,3491,3497,3503 'primarycolor':3173,3219 'privaci':3190,3232,3252 'problem':2506 'process':3019,3059,3061 'product':1548,1552,1576,1600,1624,1768,1825,2257,3003,3006,3376,3458 'productid':1514,2264,2374 'productnam':1516,2376 'profil':1332,1363,1418,2891,2901,2902,2936,2937 'profile.firstname':2905,2908,2948 'profile.lastname':2906,2909,2952 'profile.nickname':2911,2913,2964 'prop':2648,2688,2691,2694,3544 'properti':2642,3819,3835,3837 'property-by-properti':3834 'provid':692 'public':832 'publicus':916 'purpl':3068 'push':2047,3182,3226,3776 'qti':3009 'quantiti':417,1518,2367,2378,3296 'quit':489 'r':1690,2794 'r.lookup':2848,2862 'rare':1462 'rate':2416,2420 're':2619,3527 'read':661 'readabl':490,1034,2572,3718,3751 'readi':1862,2984 'real':156,161,2973 'real-world':155,2972 'real-world-exampl':160 'recommend':3769 'record':1240,1405,1536,1543,1550,1708,1727,2027,2032,2070,2087,2154,2173,2178,2212,2230,2274,2279,2317,2336,2817,3048 'record/dictionary':2789 'recurs':3846 'reduc':392,473,3519,3708,3795,3797 'reduct':508 'remov':678,943,948 'repeat':3654,3680,3831 'replac':190 'report':1996 'requir':2883,3977 'reshap':36,86,810 'respons':40,88,658,1461,1479,1489,1495,1588,1814,1858,2980,2988 'response.orders':1607,1820,1824,1828 'rest':1397,1409 'result':227,241,334,346,553,572,893,895,900,994,1002,1005,1211,1224,1255,1269,1276,2031,2041,2043,2045,2050,2139,3620,3736,3757 'result.api':1215 'result.push':236,343,564 'result.sort':566 'result.ui':1220 'retri':1196,1286 'return':240,345,435,571,863,899,969,1004,1083,1223,1275,1389,1399,1668,1934,2049,2080,2192,2222,2293,2327,2440,2477,2536,2538,2645,2747,2844,2907,2912,2914,3122,3336,3582,3744 'reus':386,602 'reusabl':296,928,1844,3479,3587,3813,3891 'revenu':2255 'revenuebycategori':2341 'revenuebyregion':3682 'review':3970 'runtim':2503 's.api':3466 's.theme':3637 'safe':18,44,91,147,152,724,744,967,970,2490,2498,2641,2706,2746,2772,2788,2843,3361,3412,3592,3854 'safeti':933,3551,3902,3980 'sale':2263,2272,2273,2284,2286,2343,2344,2346,2347,2349,3684,3685,3687,3688,3690 'sale.amount':2292,2348,3689 'sale.category':2288,2290,2345 'sale.region':3686 'sanitizeforlog':957,1011 'say':285 'scenario':3448 'scope':3951 'section':49 'select':824 'sensit':815,949 'separ':379 'seri':666 'servic':3369 'set':818,1059,1066,1079,1082,1110,1113,1119,1333,1365,1419,3162,3214,3271 'shape':1465 'shine':66,494,3617 'ship':2243,3020,3064,3066 'short':1940,3096 'show':50 'showact':3193,3235 'showprofil':3191,3233 'simpl':363,482,2557,3515,3802,3863,3923 'simplest':3434 'singl':657 'skill':24,3943 'skill-fp-data-transforms' 'small':3176 'sms':3184,3228,3263 'someth':395 'sort':531,592,643,675 'sortedscor':790 'sourc':1207,1245,1262,1266,1273 'source-sickn33' 'source.api':1214,1217 'source.ui':1219,1222 'specif':825,944,3646,3965 'spread':1153,1164,1351,1425,3824,3838,3841 'state':1330,1338,1339,1355,1356,1359,1360,1416,1482,1493,1527,1592,1669,3900 'state.customers.allids.push':1621 'state.customers.byid':1611,1613 'state.orders.allids.push':1666 'state.orders.byid':1655 'state.products.allids.push':1648 'state.products.byid':1638,1640 'state.user':1362 'state.user.profile':1364 'state.user.profile.settings':1366 'state.user.profile.settings.theme':1343 'status':1524,1565,1664,1806,2165,3017,3046,3117,3118 'status.color':3147 'status.label':3145 'status_config.pending':3121 'statuscolor':3042,3146 'statuslabel':3040,3144 'step':651,668,680,3578,3607 'stop':2492,3971 'string':323,325,414,539,541,551,554,580,620,625,627,635,844,846,848,850,852,858,860,862,1075,1193,1200,1241,1335,1341,1358,1382,1406,1505,1507,1509,1511,1515,1517,1525,1537,1540,1544,1547,1551,1554,1558,1560,1562,1566,1570,1572,1574,1578,1580,1631,1706,1709,1712,1718,1728,1883,1886,1889,1892,1895,1897,1900,1908,1910,1912,1914,1918,1927,1928,2016,2018,2022,2028,2033,2062,2095,2155,2174,2179,2205,2265,2267,2275,2280,2306,2375,2377,2385,2513,2531,2549,2818,2893,2895,2897,2903,2938,2993,2996,2999,3005,3008,3016,3029,3031,3037,3039,3041,3043,3049,3051,3053,3078,3086,3087,3174,3285,3287,3289,3293,3299,3303,3305,3373,3375,3377,3384,3388,3392,3459,3747 'structur':1477,2501 'sub':2432,2438,2442,2445,2466,2479,2481,2484 'substitut':3961 'subtot':2401,2425,2433,2441,2478 'success':3983 'suffic':3542 'sum':483,2406,2408,3109,3111,3131,3133,3318,3320,3351,3353 'sumbi':2247,2299,2302,2342,3650,3683 'sumbycategori':2271 'summari':3765 'support':699 'syntax':1154,3839 'system':3172,3218 'tabl':111 'take':783 'target':1205,1212,1243,1256,1271 'target.api':1216 'target.ui':1221 'task':84,202,309,398,522,828,947,1056,1181,1317,1484,1865,2005,2161,2252,2360,2875,3766,3947 'tax':2427,2436,2443,2446,2480 'taxrat':2388 'team':3534,3665,3934 'test':387,3967 'testabl':1839 'theme':1067,1084,1120,1131,1140,1199,1289,1301,1334,1367,1420,3168,3216,3246,3259 'third':749,2777 'throw':2734 'tier':544 'time':3664 'timeout':1194,1284,1298 'todisplayus':1950,1979,1984 'todollar':260,269,292 'tofix':3081 'token':3383 'tolocaledatestr':3091 'toordersummari':3102,3152,3157 'topic-agent-skills' 'topic-agentic-skills' 'topic-ai-agent-skills' 'topic-ai-agents' 'topic-ai-coding' 'topic-ai-workflows' 'topic-antigravity' 'topic-antigravity-skills' 'topic-claude-code' 'topic-claude-code-skills' 'topic-codex-cli' 'topic-codex-skills' 'topthre':788 'total':401,425,432,436,446,448,457,1522,1563,1662,1804,2019,2254,2278,2287,2289,2294,2321,2328,2330,2362,2429,2444,2483,3034,3107,3136,3139,3280 'totalsp':3308,3349 'track':3600 'transform':4,7,22,28,73,123,127,187,198,286,290,504,663,807,1046,1470,1485,1856,1974,2624,2978,3044,3148,3516,3533,3585,3588,3662,3770,3892,3914 'treat':3956 'tri':2940 'trivial':682 'true':1125,1145,1292,3225,3227,3234,3236,3238,3264 'ts':686,691,707,715,722,1444,1678,1686,1694,2114,2123,2130,2450,2459,2576,2596,2632,2639,2716,2724,2731,2798,2806,2813,2925,2932,3399,3406,3570,3616 'two':773 'type':932,1849,3197,3379,3411,3591,3901 'type-saf':3410,3590 'typescript':82,214,252,319,349,410,439,535,575,700,840,872,955,973,1064,1106,1188,1227,1328,1349,1499,1531,1585,1672,1874,1923,2012,2053,2116,2168,2196,2261,2297,2371,2392,2507,2526,2543,2544,2625,2709,2791,2889,2986,3165,3281,3366,3553,3613,3673,3727 'u':2866,3562,3565,3624,3628 'u.email':2867 'u.id':3625 'u.isactive':3563 'u.name':3566 'u.profile':3630 'ui':1198,1288,1300,1861,2983,3024 'ui-readi':1860,2982 'ui.animations':1309 'ui.theme':1307 'undefin':1086,1091,1096,1101,1268,2659,2745,2835,2842,3423 'uniqu':793 'uniquetag':796 'unit':2369,3011 'unitpric':2380 'unknown':1392,1407 'unknown@example.com':2869 'updat':820,1312,1318,1434 'updatepath':1376,1402,1415 'updatethem':1337,1354 'url':1899,1971 'us':1938,3094 'usag':1116,1277,2090,2233,2339,3255,3430 'use':8,69,167,173,683,1436,2111,2573,2590,2593,3449,3509,3511,3567,3640,3679,3778,3787,3796,3823,3840,3848,3861,3941 'user':313,321,330,331,332,335,338,340,344,352,353,368,530,537,549,550,557,559,578,579,581,583,586,590,605,606,611,612,618,619,633,634,636,765,767,779,781,836,842,855,856,908,918,958,959,961,968,1013,1058,1331,1361,1417,1881,1977,2816,2819,2820,2826,2837,2838,2839,2841,2847,2849,2851,2854,2861,2863,2878,3161,3243,3372,3443,3456,3560,3622 'user.email':869 'user.id':768,865 'user.isactive':342,355,369,561,584,608,782 'user.name':565,591,621,867 'user.notifications':3251 'user.privacy':3254 'user.theme':3248 'user.tier':562,587,614 'userid':3626 'userpref':1129,1139 'userprefer':3257,3272 'users.filter':358,367 'userset':1080,1111,1115 'usersettings.fontsize':1090,1092 'usersettings.language':1100,1102 'usersettings.notifications':1095,1097 'usersettings.theme':1085,1087 'util':695,875,926,976,1038,2056,2199,2300,3642,3675,3811,3814,3822,3829,3847,3849 'v':1378,1384 'valid':3966 'valu':47,80,794,822,1315,1322,1383,1390,1410,2250,2587,2608,2617,2873,3483,3545,3790,3894,3905 've':3733,3931 'verbos':191,1428,1447,2524 'version':493,3755 'void':1342 'vs':3748 'want':97,2610,3596,3890 'week':3189 'when-to-use-what':170 'without':1323,2502 'work':33,104 'world':157,162,2974 'worth':3725 'write':2493,3659 'x':2495,3857 'x.y':2496,3858 'x.y.z':2497 'year':1941,3099 'yellow':3058","prices":[{"id":"5143a1bf-729f-4938-b6fd-3ea17571124c","listingId":"acb9299f-ce2a-4ed3-a5fa-565c1d1115bd","amountUsd":"0","unit":"free","nativeCurrency":null,"nativeAmount":null,"chain":null,"payTo":null,"paymentMethod":"skill-free","isPrimary":true,"details":{"org":"sickn33","category":"antigravity-awesome-skills","install_from":"skills.sh"},"createdAt":"2026-04-18T21:37:24.468Z"}],"sources":[{"listingId":"acb9299f-ce2a-4ed3-a5fa-565c1d1115bd","source":"github","sourceId":"sickn33/antigravity-awesome-skills/fp-data-transforms","sourceUrl":"https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/fp-data-transforms","isPrimary":false,"firstSeenAt":"2026-04-18T21:37:24.468Z","lastSeenAt":"2026-04-24T00:50:57.841Z"}],"details":{"listingId":"acb9299f-ce2a-4ed3-a5fa-565c1d1115bd","quickStartSnippet":null,"exampleRequest":null,"exampleResponse":null,"schema":null,"openapiUrl":null,"agentsTxtUrl":null,"citations":[],"useCases":[],"bestFor":[],"notFor":[],"kindDetails":{"org":"sickn33","slug":"fp-data-transforms","github":{"repo":"sickn33/antigravity-awesome-skills","stars":34793,"topics":["agent-skills","agentic-skills","ai-agent-skills","ai-agents","ai-coding","ai-workflows","antigravity","antigravity-skills","claude-code","claude-code-skills","codex-cli","codex-skills","cursor","cursor-skills","developer-tools","gemini-cli","gemini-skills","kiro","mcp","skill-library"],"license":"mit","html_url":"https://github.com/sickn33/antigravity-awesome-skills","pushed_at":"2026-04-24T00:28:59Z","description":"Installable GitHub library of 1,400+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.","skill_md_sha":"c8ec1c0da05e72776720502a6872c4fa02df4de4","skill_md_path":"skills/fp-data-transforms/SKILL.md","default_branch":"main","skill_tree_url":"https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/fp-data-transforms"},"layout":"multi","source":"github","category":"antigravity-awesome-skills","frontmatter":{"name":"fp-data-transforms","description":"Everyday data transformations using functional patterns - arrays, objects, grouping, aggregation, and null-safe access"},"skills_sh_url":"https://skills.sh/sickn33/antigravity-awesome-skills/fp-data-transforms"},"updatedAt":"2026-04-24T00:50:57.841Z"}}