vue2-excel-grid 1.0.0

package/src/utils/excelImportCore.js

@@ -0,0 +1,247 @@
+/**
+ * Pure header-detection / column-tree-building logic shared by the main-thread
+ * import path (excelImport.js) and the Web Worker import path
+ * (excelImportWorker.worker.js), so the two never drift apart.
+ */
+
+export function slugify(str) {
+  if (!str) return ''
+  return String(str)
+    .toLowerCase()
+    .replace(/\s+/g, '_')
+    .replace(/[^a-z0-9_]/g, '')
+    .replace(/^(\d)/, 'col_$1')
+    || 'col'
+}
+
+export function flatLeaves(cols) {
+  const result = []
+  for (const col of (cols || [])) {
+    if (col.children && col.children.length) {
+      result.push(...flatLeaves(col.children))
+    } else if (col.key) {
+      result.push(col)
+    }
+  }
+  return result
+}
+
+/**
+ * Auto-detect header block and data start.
+ *
+ * @param {Array<Array<string>>} aoa
+ * @param {Array<{s:{r,c},e:{r,c}}>} merges — aoa-relative (already offset-corrected)
+ *
+ * 1. Look for a "column-number row" — a row where every non-empty cell is an
+ *    integer and they form the exact sequence 1, 2, 3 … N (common in official
+ *    government/accounting Excel registers).
+ *    When found:
+ *      dataStartRow  = columnNumberRow + 1
+ *      headerEndRow  = first non-empty row strictly above columnNumberRow
+ *      headerRow     = walk up further while rows still have >1 non-empty cells
+ * 2. Fallback (no column-number row):
+ *      Skip leading title rows (≤1 non-empty cell).
+ *      First row with >1 non-empty cells = headerRow.
+ *      headerEndRow extends downward to the tallest merge anchored at headerRow
+ *      (handles multi-row merged headers, e.g. grouped column headers).
+ * In both cases, any fully blank rows right after the header block (a visual
+ * separator row) are skipped before settling on dataStartRow.
+ */
+export function detectImportBounds(aoa, merges) {
+  if (!aoa || aoa.length === 0) return { headerRow: 0, headerEndRow: 0, dataStartRow: 1 }
+
+  const nonEmpty = aoa.map(row => row.filter(c => c !== '').length)
+  merges = merges || []
+
+  let colNumRow = -1
+  for (let i = 0; i < Math.min(aoa.length, 20); i++) {
+    const vals = aoa[i].filter(c => c !== '')
+    if (vals.length < 2) continue
+    const nums = vals.map(v => {
+      const n = parseInt(String(v).trim(), 10)
+      return isNaN(n) ? null : n
+    })
+    if (nums.some(n => n === null)) continue
+    if (nums.every((n, idx) => n === idx + 1)) { colNumRow = i; break }
+  }
+
+  let headerRow, headerEndRow, dataStartRow
+
+  if (colNumRow >= 0) {
+    dataStartRow = colNumRow + 1
+    headerEndRow = colNumRow - 1
+    while (headerEndRow >= 0 && nonEmpty[headerEndRow] === 0) headerEndRow--
+    if (headerEndRow < 0) headerEndRow = 0
+    headerRow = headerEndRow
+    while (headerRow > 0 && nonEmpty[headerRow - 1] > 1) headerRow--
+  } else {
+    headerRow = 0
+    for (let i = 0; i < Math.min(aoa.length, 20); i++) {
+      if (nonEmpty[i] > 1) { headerRow = i; break }
+    }
+    let maxSpan = 1
+    for (const m of merges) {
+      if (m.s.r === headerRow && m.e.r > m.s.r) {
+        maxSpan = Math.max(maxSpan, m.e.r - m.s.r + 1)
+      }
+    }
+    headerEndRow = headerRow + maxSpan - 1
+    dataStartRow = headerEndRow + 1
+  }
+
+  while (dataStartRow < aoa.length && nonEmpty[dataStartRow] === 0) dataStartRow++
+
+  return { headerRow, headerEndRow, dataStartRow }
+}
+
+/**
+ * Check whether there is any non-empty cell in aoa[rowStart..rowEnd][colStart..colEnd].
+ */
+export function hasNonEmptyInRange(aoa, rowStart, rowEnd, colStart, colEnd) {
+  for (let r = rowStart; r <= rowEnd; r++) {
+    for (let c = colStart; c <= colEnd; c++) {
+      if (((aoa[r] || [])[c] || '').toString().trim() !== '') return true
+    }
+  }
+  return false
+}
+
+export function cellText(aoa, r, c) {
+  return String(((aoa[r] || [])[c] || '')).trim().replace(/\n/g, ' ')
+}
+
+/**
+ * Build a nested column tree from the multi-row header block, plus a flat
+ * colMap list used for mapping data rows.
+ *
+ * Rules:
+ *  - A merge that spans multiple COLUMNS (horizontal) → always a PARENT; its
+ *    children are the header items found in the rows below the merge.
+ *  - A merge that spans a single column all the way to headerEndRow → LEAF.
+ *  - A plain cell (no merge) on the last header row → LEAF.
+ *  - A plain cell (no merge) above the last header row with non-empty content
+ *    below it → PARENT; otherwise LEAF.
+ *
+ * @returns {{ columns: Column[], colMap: Array<{key, colIndex}> }}
+ */
+export function buildNestedColumns(aoa, headerRow, headerEndRow, sheetMerges, existingLeaves, usedSlugs) {
+  // Determine the last meaningful column index from header content + merges
+  let maxCol = -1
+  for (let r = headerRow; r <= headerEndRow; r++) {
+    for (let c = (aoa[r] || []).length - 1; c >= 0; c--) {
+      if (((aoa[r] || [])[c] || '') !== '') { maxCol = Math.max(maxCol, c); break }
+    }
+  }
+  const headerMerges = (sheetMerges || []).filter(
+    m => m.s.r >= headerRow && m.s.r <= headerEndRow
+  )
+  for (const m of headerMerges) maxCol = Math.max(maxCol, m.e.c)
+  if (maxCol < 0) return { columns: [], colMap: [] }
+
+  const colMap = []
+
+  function makeLeaf(title, colIndex) {
+    const matched = existingLeaves.find(
+      l => l.title && l.title.toLowerCase() === title.toLowerCase()
+    )
+    if (matched) {
+      return { key: matched.key, title: matched.title, width: matched.width || 100 }
+    }
+    // Build a slug that strips non-ASCII chars AND collapses leftover underscores.
+    // Fall back to a positional key so Cyrillic-only titles never get just '_'.
+    const rawSlug = String(title || '')
+      .toLowerCase()
+      .replace(/\s+/g, '_')
+      .replace(/[^a-z0-9_]/g, '')
+      .replace(/^_+|_+$/g, '')
+      .replace(/_+/g, '_')
+      .replace(/^(\d)/, 'col_$1')
+    let slug = rawSlug || `col_${colIndex}`
+    let finalSlug = slug
+    let n = 1
+    while (usedSlugs.has(finalSlug) || existingLeaves.some(l => l.key === finalSlug)) {
+      finalSlug = `${slug}_${n++}`
+    }
+    usedSlugs.add(finalSlug)
+    return { key: finalSlug, title: title || finalSlug, width: 100 }
+  }
+
+  function processRange(rowStart, rowEnd, colStart, colEnd) {
+    if (rowStart > rowEnd || colStart > colEnd) return []
+    const result = []
+    let c = colStart
+
+    while (c <= colEnd) {
+      // Skip cells covered by a horizontal merge that started to the left
+      const covered = headerMerges.some(m =>
+        m.s.r <= rowStart && m.e.r >= rowStart &&
+        m.s.c < c && m.e.c >= c
+      )
+      if (covered) { c++; continue }
+
+      const startMerge = headerMerges.find(m => m.s.r === rowStart && m.s.c === c)
+      const title = startMerge
+        ? cellText(aoa, startMerge.s.r, startMerge.s.c)
+        : cellText(aoa, rowStart, c)
+
+      if (startMerge && startMerge.e.c > c) {
+        // ── Horizontal span ─────────────────────────────────────────────────
+        const spanColEnd = Math.min(startMerge.e.c, colEnd)
+        const childRowStart = startMerge.e.r + 1
+
+        if (childRowStart <= rowEnd && hasNonEmptyInRange(aoa, childRowStart, rowEnd, c, spanColEnd)) {
+          const children = processRange(childRowStart, rowEnd, c, spanColEnd)
+          result.push({ title, children })
+        } else {
+          // No sub-headers below → individual leaf per physical column
+          for (let ci = c; ci <= spanColEnd; ci++) {
+            const leaf = makeLeaf(title, ci)
+            result.push(leaf)
+            colMap.push({ key: leaf.key, colIndex: ci })
+          }
+        }
+        c = spanColEnd + 1
+      } else if (startMerge && startMerge.e.r >= rowEnd) {
+        // ── Single-column merge spanning to bottom row ─── LEAF ────────────
+        const leaf = makeLeaf(title, c)
+        result.push(leaf)
+        colMap.push({ key: leaf.key, colIndex: c })
+        c++
+      } else if (startMerge) {
+        // ── Single-column merge that ends before bottom row ─────────────────
+        const childRowStart = startMerge.e.r + 1
+        if (childRowStart <= rowEnd && hasNonEmptyInRange(aoa, childRowStart, rowEnd, c, c)) {
+          const children = processRange(childRowStart, rowEnd, c, c)
+          result.push({ title, children })
+        } else {
+          const leaf = makeLeaf(title, c)
+          result.push(leaf)
+          colMap.push({ key: leaf.key, colIndex: c })
+        }
+        c++
+      } else if (rowStart === rowEnd) {
+        // ── Last header row, plain cell ─── LEAF ───────────────────────────
+        const leaf = makeLeaf(title, c)
+        result.push(leaf)
+        colMap.push({ key: leaf.key, colIndex: c })
+        c++
+      } else {
+        // ── Upper row, plain cell — check for non-empty content below ───────
+        if (hasNonEmptyInRange(aoa, rowStart + 1, rowEnd, c, c)) {
+          const children = processRange(rowStart + 1, rowEnd, c, c)
+          result.push({ title, children })
+        } else {
+          const leaf = makeLeaf(title, c)
+          result.push(leaf)
+          colMap.push({ key: leaf.key, colIndex: c })
+        }
+        c++
+      }
+    }
+
+    return result
+  }
+
+  const columns = processRange(headerRow, headerEndRow, 0, maxCol)
+  return { columns, colMap }
+}

package/src/utils/excelImportWorker.worker.js

@@ -0,0 +1,104 @@
+/**
+ * Web Worker — Excel/CSV import.
+ *
+ * Protocol:
+ *   IN  postMessage({ buffer: ArrayBuffer, existingColumns: [], options: {} })
+ *   OUT postMessage({ type: 'progress', percent, message })
+ *   OUT postMessage({ type: 'result',   data, columns, merges })
+ *   OUT postMessage({ type: 'error',    message })
+ */
+import * as XLSX from 'xlsx'
+import { flatLeaves, detectImportBounds, buildNestedColumns } from './excelImportCore.js'
+
+const CHUNK_SIZE = 5000
+
+self.onmessage = function (e) {
+  const { buffer, existingColumns, options } = e.data
+  const report = (percent, message) =>
+    self.postMessage({ type: 'progress', percent, message })
+
+  try {
+    report(10, 'Excel tahlil qilinmoqda...')
+
+    let workbook
+    try {
+      workbook = XLSX.read(new Uint8Array(buffer), { type: 'array', cellDates: true })
+    } catch (err) {
+      throw new Error("Excel fayl o'qib bo'lmadi: " + err.message)
+    }
+
+    const { sheetName } = options || {}
+    let sheet
+    if (sheetName) {
+      sheet = workbook.Sheets[sheetName]
+      if (!sheet) throw new Error(`Sheet "${sheetName}" topilmadi`)
+    } else {
+      const first = workbook.SheetNames[0]
+      if (!first) throw new Error("Workbook bo'sh")
+      sheet = workbook.Sheets[first]
+    }
+
+    report(30, "Ma'lumotlar tayyorlanmoqda...")
+
+    const aoa = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: '' })
+    if (!aoa || aoa.length === 0) throw new Error("Sheet bo'sh")
+
+    // `sheet['!merges']` row/col indices are sheet-absolute, but `aoa` is relative
+    // to the sheet's used range (e.g. starts at A2 instead of A1). Normalize merges
+    // to aoa-relative coordinates so they line up with header/data row indices below.
+    const usedRange = XLSX.utils.decode_range(sheet['!ref'] || 'A1:A1')
+    const rowOffset = usedRange.s.r
+    const colOffset = usedRange.s.c
+    const merges = (sheet['!merges'] || []).map(m => ({
+      s: { r: m.s.r - rowOffset, c: m.s.c - colOffset },
+      e: { r: m.e.r - rowOffset, c: m.e.c - colOffset }
+    }))
+
+    const detected = detectImportBounds(aoa, merges)
+    const headerRowIdx    = (options && options.headerRow    != null) ? options.headerRow    : detected.headerRow
+    const headerEndRowIdx = (options && options.headerEndRow != null) ? options.headerEndRow : detected.headerEndRow
+    const dataStartRowIdx = (options && options.dataStartRow != null) ? options.dataStartRow : detected.dataStartRow
+
+    const existingLeaves = flatLeaves(existingColumns)
+    const usedSlugs = new Set()
+
+    const { columns: newColumns, colMap } = buildNestedColumns(
+      aoa, headerRowIdx, headerEndRowIdx, merges,
+      existingLeaves, usedSlugs
+    )
+
+    const totalDataRows = Math.max(aoa.length - dataStartRowIdx, 0)
+    report(50, `Qatorlar qayta ishlanmoqda (0 / ${totalDataRows})...`)
+
+    const data = []
+    for (let i = dataStartRowIdx; i < aoa.length; i += CHUNK_SIZE) {
+      const end = Math.min(i + CHUNK_SIZE, aoa.length)
+      for (let r = i; r < end; r++) {
+        const rowArr = aoa[r]
+        const obj = {}
+        for (const { key, colIndex } of colMap) {
+          obj[key] = rowArr[colIndex] !== undefined ? rowArr[colIndex] : ''
+        }
+        data.push(obj)
+      }
+      const processed = Math.min(end - dataStartRowIdx, totalDataRows)
+      const pct = 50 + Math.round(45 * processed / Math.max(totalDataRows, 1))
+      report(pct, `Qatorlar: ${processed} / ${totalDataRows}`)
+    }
+
+    const dataMerges = merges
+      .filter(m => m.s.r >= dataStartRowIdx)
+      .map(m => ({
+        startRow: m.s.r - dataStartRowIdx,
+        startCol: m.s.c,
+        endRow:   m.e.r - dataStartRowIdx,
+        endCol:   m.e.c
+      }))
+      .filter(m => m.startRow >= 0 && m.startCol >= 0)
+
+    report(100, 'Tayyor!')
+    self.postMessage({ type: 'result', data, columns: newColumns, merges: dataMerges })
+  } catch (err) {
+    self.postMessage({ type: 'error', message: err.message })
+  }
+}

package/src/utils/fillHandle.js

@@ -0,0 +1,119 @@
+/**
+ * Fill handle: pattern detection and value generation
+ */
+
+const WEEKDAYS_UZ = ['Dushanba', 'Seshanba', 'Chorshanba', 'Payshanba', 'Juma', 'Shanba', 'Yakshanba']
+const WEEKDAYS_EN = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+const MONTHS_EN = ['January', 'February', 'March', 'April', 'May', 'June',
+                   'July', 'August', 'September', 'October', 'November', 'December']
+
+// ISO date pattern: YYYY-MM-DD or YYYY/MM/DD
+const ISO_DATE_RE = /^\d{4}[-/]\d{2}[-/]\d{2}$/
+
+/**
+ * Detect if a value looks like an ISO date string (not just a number starting with year)
+ */
+function isDateLike(v) {
+  return typeof v === 'string' && ISO_DATE_RE.test(v.trim())
+}
+
+/**
+ * Check if a value is purely numeric (strict, no date-like strings)
+ */
+function isPureNumber(v) {
+  if (typeof v === 'boolean') return false
+  const s = String(v).trim()
+  if (s === '') return false
+  if (isDateLike(s)) return false
+  return !isNaN(Number(s))
+}
+
+/**
+ * Detect pattern type from an array of values.
+ * Returns: { type: 'number'|'date'|'weekday_uz'|'weekday_en'|'month'|'copy', step, base }
+ */
+export function detectPattern(values) {
+  if (values.length === 0) return { type: 'copy', step: 0, base: null }
+  if (values.length === 1) return { type: 'copy', step: 0, base: values[0] }
+
+  // Weekdays (Uzbek)?
+  const uzIdxs = values.map(v => WEEKDAYS_UZ.indexOf(v))
+  if (uzIdxs.every(i => i >= 0)) {
+    const step = values.length >= 2 ? ((uzIdxs[1] - uzIdxs[0] + 7) % 7) || 1 : 1
+    return { type: 'weekday_uz', step, base: uzIdxs[0] }
+  }
+
+  // Weekdays (English)?
+  const enIdxs = values.map(v => WEEKDAYS_EN.indexOf(v))
+  if (enIdxs.every(i => i >= 0)) {
+    const step = values.length >= 2 ? ((enIdxs[1] - enIdxs[0] + 7) % 7) || 1 : 1
+    return { type: 'weekday_en', step, base: enIdxs[0] }
+  }
+
+  // Months (English)?
+  const mIdxs = values.map(v => MONTHS_EN.indexOf(v))
+  if (mIdxs.every(i => i >= 0)) {
+    const step = values.length >= 2 ? ((mIdxs[1] - mIdxs[0] + 12) % 12) || 1 : 1
+    return { type: 'month', step, base: mIdxs[0] }
+  }
+
+  // ISO Date strings? (check before numbers to avoid '2024-01-01' being parsed as 2024)
+  if (values.every(isDateLike)) {
+    const times = values.map(v => new Date(v).getTime())
+    if (times.every(t => !isNaN(t))) {
+      const steps = times.slice(1).map((t, i) => t - times[i])
+      const isLinear = steps.every(s => Math.abs(s - steps[0]) < 86400000) // within 1 day tolerance
+      if (isLinear) return { type: 'date', step: steps[0], base: times[0] }
+    }
+  }
+
+  // All pure numbers?
+  if (values.every(isPureNumber)) {
+    const nums = values.map(v => Number(v))
+    const steps = nums.slice(1).map((n, i) => n - nums[i])
+    const isLinear = steps.every(s => Math.abs(s - steps[0]) < 1e-10)
+    if (isLinear) return { type: 'number', step: steps[0], base: nums[0] }
+  }
+
+  return { type: 'copy', step: 0, base: values[0] }
+}
+
+/**
+ * Generate fill values for `count` additional cells beyond the source values.
+ *
+ * @param {Array} sourceValues - the source cell values
+ * @param {number} count       - how many new values to generate
+ * @returns {Array}
+ */
+export function generateFillValues(sourceValues, count) {
+  const pattern = detectPattern(sourceValues)
+  const n = sourceValues.length
+  const result = []
+
+  for (let i = 0; i < count; i++) {
+    const pos = n + i // absolute position from start
+    switch (pattern.type) {
+      case 'number':
+        result.push(pattern.base + pattern.step * pos)
+        break
+      case 'weekday_uz':
+        result.push(WEEKDAYS_UZ[(pattern.base + pattern.step * pos) % 7])
+        break
+      case 'weekday_en':
+        result.push(WEEKDAYS_EN[(pattern.base + pattern.step * pos) % 7])
+        break
+      case 'month':
+        result.push(MONTHS_EN[(pattern.base + pattern.step * pos) % 12])
+        break
+      case 'date': {
+        const d = new Date(pattern.base + pattern.step * pos)
+        result.push(d.toISOString().split('T')[0])
+        break
+      }
+      default:
+        // copy: cycle through source values
+        result.push(sourceValues[pos % n])
+    }
+  }
+  return result
+}

package/src/utils/headerTree.js

@@ -0,0 +1,108 @@
+/**
+ * Utilities for building and traversing the nested column header tree
+ */
+
+/**
+ * Flatten the column tree into a list of leaf columns (those with a `key`).
+ * Returns an array of leaf column definitions, each augmented with their
+ * flat index (`_flatIndex`).
+ *
+ * @param {Array} columns - raw column config (may contain `children`)
+ * @returns {Array} flat leaf columns
+ */
+export function flattenColumns(columns) {
+  const leaves = []
+  function walk(cols) {
+    for (const col of cols) {
+      if (col.children && col.children.length) {
+        walk(col.children)
+      } else {
+        leaves.push({ ...col, _flatIndex: leaves.length })
+      }
+    }
+  }
+  walk(columns)
+  return leaves
+}
+
+/**
+ * Compute the maximum depth of the column tree (for multi-row headers).
+ * A flat column has depth 1.
+ */
+export function columnTreeDepth(columns) {
+  function depth(cols) {
+    let max = 0
+    for (const col of cols) {
+      if (col.children && col.children.length) {
+        max = Math.max(max, 1 + depth(col.children))
+      } else {
+        max = Math.max(max, 1)
+      }
+    }
+    return max
+  }
+  return depth(columns)
+}
+
+/**
+ * Build header rows suitable for rendering.
+ * Each header row is an array of header cell descriptors:
+ *   { column, colspan, rowspan, isGroup }
+ *
+ * @param {Array} columns
+ * @param {number} totalDepth - from columnTreeDepth()
+ * @returns {Array<Array>} rows of header cell objects
+ */
+export function buildHeaderRows(columns, totalDepth) {
+  const rows = Array.from({ length: totalDepth }, () => [])
+  let flatIndex = 0
+
+  function walk(cols, rowIndex) {
+    for (const col of cols) {
+      if (col.children && col.children.length) {
+        const leafCount = countLeaves(col)
+        const firstLeafFlatIndex = flatIndex  // capture before descending
+        rows[rowIndex].push({
+          column: col,
+          colspan: leafCount,
+          rowspan: 1,
+          isGroup: true,
+          _firstLeafFlatIndex: firstLeafFlatIndex
+        })
+        walk(col.children, rowIndex + 1)
+      } else {
+        const rowspan = totalDepth - rowIndex
+        rows[rowIndex].push({
+          column: { ...col, _flatIndex: flatIndex },
+          colspan: 1,
+          rowspan,
+          isGroup: false,
+          _firstLeafFlatIndex: flatIndex
+        })
+        flatIndex++
+      }
+    }
+  }
+
+  walk(columns, 0)
+  return rows
+}
+
+/**
+ * Count the number of leaf columns under a column node
+ */
+export function countLeaves(col) {
+  if (!col.children || col.children.length === 0) return 1
+  return col.children.reduce((sum, c) => sum + countLeaves(c), 0)
+}
+
+/**
+ * Get the total width of a column node (sum of all leaf widths)
+ */
+export function columnTotalWidth(col, leafWidths) {
+  if (!col.children || col.children.length === 0) {
+    const idx = col._flatIndex
+    return leafWidths[idx] !== undefined ? leafWidths[idx] : (col.width || 100)
+  }
+  return col.children.reduce((sum, c) => sum + columnTotalWidth(c, leafWidths), 0)
+}

package/src/utils/i18n.js

@@ -0,0 +1,101 @@
+/**
+ * Context menu translations for ExcelGrid.
+ * Supported locales: 'en' | 'ru' | 'uz' | 'uz-Cyrl'
+ */
+const messages = {
+  en: {
+    copy:           'Copy',
+    cut:            'Cut',
+    paste:          'Paste',
+    pasteSpecial:   'Paste Special',
+    pasteAll:       'All (Value + Format)',
+    pasteValues:    'Values Only',
+    pasteFormats:   'Formats Only',
+    transpose:      'Transpose',
+    mergeCells:     'Merge Cells',
+    unmergeCells:   'Unmerge Cells',
+    hideRows:       'Hide Row(s)',
+    hideColumns:    'Hide Column(s)',
+    unhideRows:     'Unhide All Rows',
+    unhideColumns:  'Unhide All Columns',
+    pinLeft:        'Pin Left',
+    pinRight:       'Pin Right',
+    unpin:          'Unpin',
+    invalidValue:   'Invalid value'
+  },
+
+  ru: {
+    copy:           'Копировать',
+    cut:            'Вырезать',
+    paste:          'Вставить',
+    pasteSpecial:   'Специальная вставка',
+    pasteAll:       'Всё (значение + формат)',
+    pasteValues:    'Только значения',
+    pasteFormats:   'Только форматы',
+    transpose:      'Транспонировать',
+    mergeCells:     'Объединить ячейки',
+    unmergeCells:   'Разъединить ячейки',
+    hideRows:       'Скрыть строку(и)',
+    hideColumns:    'Скрыть столбец(цы)',
+    unhideRows:     'Показать все строки',
+    unhideColumns:  'Показать все столбцы',
+    pinLeft:        'Закрепить слева',
+    pinRight:       'Закрепить справа',
+    unpin:          'Открепить',
+    invalidValue:   'Недопустимое значение'
+  },
+
+  uz: {
+    copy:           'Nusxalash',
+    cut:            'Kesib olish',
+    paste:          'Joylashtirish',
+    pasteSpecial:   'Maxsus joylashtirish',
+    pasteAll:       'Hammasi (qiymat + format)',
+    pasteValues:    'Faqat qiymatlar',
+    pasteFormats:   'Faqat formatlar',
+    transpose:      'Transpozitsiya',
+    mergeCells:     'Katakchalarni birlashtirish',
+    unmergeCells:   'Katakchalarni ajratish',
+    hideRows:       'Qatorlarni yashirish',
+    hideColumns:    'Ustunlarni yashirish',
+    unhideRows:     'Barcha qatorlarni ko\'rsatish',
+    unhideColumns:  'Barcha ustunlarni ko\'rsatish',
+    pinLeft:        'Chapga pin qilish',
+    pinRight:       'O\'ngga pin qilish',
+    unpin:          'Pindan olish',
+    invalidValue:   'Noto\'g\'ri qiymat'
+  },
+
+  'uz-Cyrl': {
+    copy:           'Нусхалаш',
+    cut:            'Кесиб олиш',
+    paste:          'Жойлаштириш',
+    pasteSpecial:   'Махсус жойлаштириш',
+    pasteAll:       'Ҳаммаси (қиймат + формат)',
+    pasteValues:    'Фақат қийматлар',
+    pasteFormats:   'Фақат форматлар',
+    transpose:      'Транспозиция',
+    mergeCells:     'Катакчаларни бирлаштириш',
+    unmergeCells:   'Катакчаларни ажратиш',
+    hideRows:       'Қаторларни яшириш',
+    hideColumns:    'Устунларни яшириш',
+    unhideRows:     'Барча қаторларни кўрсатиш',
+    unhideColumns:  'Барча устунларни кўрсатиш',
+    pinLeft:        'Чапга пин қилиш',
+    pinRight:       'Ўнгга пин қилиш',
+    unpin:          'Пиндан олиш',
+    invalidValue:   'Нотўғри қиймат'
+  }
+}
+
+/**
+ * Returns the translation object for the given locale.
+ * Falls back to 'en' if the locale is unknown.
+ * @param {string} locale
+ * @returns {Object}
+ */
+export function getMessages(locale) {
+  return messages[locale] || messages.en
+}
+
+export default messages