@coreui/data-grid 0.1.0-rc.0 → 0.2.0-rc.0

package/src/util/xlsx.ts

@@ -0,0 +1,183 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/xlsx.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+
+import {
+ columnsFor, formatterFor, headerFor, rowsFor, widthFor, type ExportColumn, type ExportScope, type ExportTable
+} from './export-table'
+import { zip, type ZipEntry } from './zip'
+
+export interface XlsxOptions {
+  scope?: ExportScope
+  sheetName?: string
+}
+
+export interface XlsxDownloadOptions extends XlsxOptions {
+  filename?: string
+}
+
+export type XlsxTable = ExportTable
+
+const MIME_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+const DEFAULT_SHEET_NAME = 'Sheet1'
+// Excel column widths count characters, not pixels: the default 8.43 width is
+// 64 px, and each further character adds 7 px on top of the 5 px padding.
+const PX_PER_CHARACTER = 7
+const CELL_PADDING_PX = 5
+const MIN_COLUMN_WIDTH = 4
+const MAX_COLUMN_WIDTH = 120
+
+// XML 1.0 forbids most control characters outright - Excel refuses to open a
+// file containing them, so they are dropped rather than escaped.
+// eslint-disable-next-line no-control-regex -- matching them is the point
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g
+
+const escapeXml = (value: string): string =>
+  value
+    .replace(CONTROL_CHARACTERS, '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+
+// A1, B1 … Z1, AA1 - Excel's bijective base-26 column reference.
+const cellReference = (columnIndex: number, rowNumber: number): string => {
+  let reference = ''
+  let index = columnIndex
+  while (index >= 0) {
+    reference = String.fromCodePoint(65 + (index % 26)) + reference
+    index = Math.floor(index / 26) - 1
+  }
+
+  return `${reference}${rowNumber}`
+}
+
+// Sheet names cannot contain : \ / ? * [ ] and cap at 31 characters.
+const sheetNameFor = (name: string | undefined): string => {
+  const cleaned = (name ?? DEFAULT_SHEET_NAME).replace(/[:\\/?*[\]]/g, ' ').trim().slice(0, 31)
+  return cleaned.length > 0 ? cleaned : DEFAULT_SHEET_NAME
+}
+
+const sheetWidthFor = (column: ExportColumn): number | null => {
+  const size = widthFor(column)
+  if (typeof size !== 'number' || !Number.isFinite(size) || size <= 0) {
+    return null
+  }
+
+  const characters = (size - CELL_PADDING_PX) / PX_PER_CHARACTER
+  return Math.min(MAX_COLUMN_WIDTH, Math.max(MIN_COLUMN_WIDTH, Math.round(characters * 100) / 100))
+}
+
+// Values reach a cell as one of three Excel types. Inline strings keep the
+// file self-contained (no shared-strings part) and are never parsed as
+// formulas, so a leading "=" is data here, unlike in CSV.
+const cellXml = (reference: string, value: unknown, styleIndex: number): string => {
+  const style = styleIndex > 0 ? ` s="${styleIndex}"` : ''
+
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return `<c r="${reference}"${style}><v>${value}</v></c>`
+  }
+
+  if (typeof value === 'boolean') {
+    return `<c r="${reference}"${style} t="b"><v>${value ? 1 : 0}</v></c>`
+  }
+
+  const text = String(value ?? '')
+  if (text === '') {
+    return `<c r="${reference}"${style}/>`
+  }
+
+  return `<c r="${reference}"${style} t="inlineStr"><is><t xml:space="preserve">${escapeXml(text)}</t></is></c>`
+}
+
+const CONTENT_TYPES = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/><Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/></Types>`
+
+const ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>`
+
+const WORKBOOK_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/></Relationships>`
+
+// Style 0 is the default cell, style 1 the bold header. Excel expects the two
+// conventional fills (none, gray125) and the built-in "Normal" cell style to
+// exist even when unused - without them readers report a missing default
+// style and Excel offers to repair the file.
+const STYLES = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><fonts count="2"><font><sz val="11"/><name val="Calibri"/></font><font><b/><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="2"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/><xf numFmtId="0" fontId="1" fillId="0" borderId="0" xfId="0" applyFont="1"/></cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`
+
+const workbookXml = (sheetName: string): string =>
+  `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="${escapeXml(sheetName)}" sheetId="1" r:id="rId1"/></sheets></workbook>`
+
+const worksheetXml = (table: XlsxTable, options: XlsxOptions): string => {
+  const columns = columnsFor(table)
+  const rows = rowsFor(table, options.scope)
+
+  const widths = columns
+    .map((column, index) => {
+      const width = sheetWidthFor(column)
+      return width === null ?
+        null :
+        `<col min="${index + 1}" max="${index + 1}" width="${width}" customWidth="1"/>`
+    })
+    .filter((entry): entry is string => entry !== null)
+  const cols = widths.length > 0 ? `<cols>${widths.join('')}</cols>` : ''
+
+  const headerCells = columns
+    .map((column, index) => cellXml(cellReference(index, 1), headerFor(column), 1))
+    .join('')
+
+  const bodyRows = rows.map((row, rowIndex) => {
+    const rowNumber = rowIndex + 2
+    const cells = columns
+      .map((column, columnIndex) => {
+        const value = row.getValue(column.id)
+        const formatter = formatterFor(column)
+        // A formatted value is text by definition; an unformatted one keeps
+        // its native type so numbers stay numeric in Excel.
+        return cellXml(
+          cellReference(columnIndex, rowNumber),
+          formatter ? formatter(value, row.original) ?? '' : value,
+          0
+        )
+      })
+      .join('')
+    return `<row r="${rowNumber}">${cells}</row>`
+  })
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">${cols}<sheetData><row r="1">${headerCells}</row>${bodyRows.join('')}</sheetData></worksheet>`
+}
+
+export const exportXlsx = (table: XlsxTable, options: XlsxOptions = {}): Uint8Array => {
+  const encoder = new TextEncoder()
+  const sheetName = sheetNameFor(options.sheetName)
+  const entries: ZipEntry[] = [
+    { name: '[Content_Types].xml', data: encoder.encode(CONTENT_TYPES) },
+    { name: '_rels/.rels', data: encoder.encode(ROOT_RELS) },
+    { name: 'xl/workbook.xml', data: encoder.encode(workbookXml(sheetName)) },
+    { name: 'xl/_rels/workbook.xml.rels', data: encoder.encode(WORKBOOK_RELS) },
+    { name: 'xl/styles.xml', data: encoder.encode(STYLES) },
+    { name: 'xl/worksheets/sheet1.xml', data: encoder.encode(worksheetXml(table, options)) }
+  ]
+
+  return zip(entries)
+}
+
+export const downloadXlsx = (table: XlsxTable, options: XlsxDownloadOptions = {}): void => {
+  const blob = new Blob([exportXlsx(table, options) as BlobPart], { type: MIME_TYPE })
+  const url = URL.createObjectURL(blob)
+  const anchor = document.createElement('a')
+  anchor.href = url
+  anchor.download = options.filename ?? 'export.xlsx'
+  anchor.style.display = 'none'
+  // Attach before clicking (older Firefox) and defer revoke (Safari race).
+  document.body.append(anchor)
+  anchor.click()
+  anchor.remove()
+  setTimeout(() => URL.revokeObjectURL(url))
+}

package/src/util/zip.ts

@@ -0,0 +1,170 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/zip.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+
+/* eslint-disable no-bitwise -- CRC32 and the ZIP header fields are defined
+   in bit terms; expressing them any other way would obscure the format. */
+
+// A minimal ZIP writer for the xlsx export. Entries are STORED (uncompressed),
+// which the format allows and which keeps the writer dependency-free - an
+// export of a few thousand rows is XML text the browser hands straight to a
+// download, so the deflate round-trip would buy little. Timestamps are fixed
+// at the DOS epoch so the same data always produces the same bytes.
+
+const DOS_EPOCH_TIME = 0
+const DOS_EPOCH_DATE = 0x0021
+// UTF-8 filename bit; every name we write is ASCII, but the flag is correct
+// and costs nothing.
+const FLAG_UTF8 = 0x0800
+
+let crcTable: Uint32Array | null = null
+
+const getCrcTable = (): Uint32Array => {
+  if (crcTable) {
+    return crcTable
+  }
+
+  const table = new Uint32Array(256)
+  for (let index = 0; index < 256; index++) {
+    let value = index
+    for (let bit = 0; bit < 8; bit++) {
+      value = value & 1 ? 0xED_B8_83_20 ^ (value >>> 1) : value >>> 1
+    }
+
+    table[index] = value >>> 0
+  }
+
+  crcTable = table
+  return table
+}
+
+const crc32 = (bytes: Uint8Array): number => {
+  const table = getCrcTable()
+  let crc = 0xFF_FF_FF_FF
+  for (const byte of bytes) {
+    crc = table[(crc ^ byte) & 0xFF]! ^ (crc >>> 8)
+  }
+
+  return (crc ^ 0xFF_FF_FF_FF) >>> 0
+}
+
+export interface ZipEntry {
+  name: string
+  data: Uint8Array
+}
+
+interface StagedEntry extends ZipEntry {
+  crc: number
+  nameBytes: Uint8Array
+  offset: number
+}
+
+const LOCAL_HEADER_SIZE = 30
+const CENTRAL_HEADER_SIZE = 46
+const END_RECORD_SIZE = 22
+
+class ByteWriter {
+  private readonly view: DataView
+  private readonly bytes: Uint8Array
+  private cursor = 0
+
+  constructor(size: number) {
+    this.bytes = new Uint8Array(size)
+    this.view = new DataView(this.bytes.buffer)
+  }
+
+  u16(value: number): void {
+    this.view.setUint16(this.cursor, value, true)
+    this.cursor += 2
+  }
+
+  u32(value: number): void {
+    this.view.setUint32(this.cursor, value, true)
+    this.cursor += 4
+  }
+
+  raw(value: Uint8Array): void {
+    this.bytes.set(value, this.cursor)
+    this.cursor += value.length
+  }
+
+  result(): Uint8Array {
+    return this.bytes
+  }
+}
+
+export const zip = (entries: ZipEntry[]): Uint8Array => {
+  const encoder = new TextEncoder()
+  const staged: StagedEntry[] = []
+  let offset = 0
+
+  for (const entry of entries) {
+    const nameBytes = encoder.encode(entry.name)
+    staged.push({
+      ...entry,
+      crc: crc32(entry.data),
+      nameBytes,
+      offset
+    })
+    offset += LOCAL_HEADER_SIZE + nameBytes.length + entry.data.length
+  }
+
+  const centralDirectoryOffset = offset
+  const centralDirectorySize = staged.reduce(
+    (total, entry) => total + CENTRAL_HEADER_SIZE + entry.nameBytes.length,
+    0
+  )
+
+  const writer = new ByteWriter(centralDirectoryOffset + centralDirectorySize + END_RECORD_SIZE)
+
+  for (const entry of staged) {
+    writer.u32(0x04_03_4B_50)
+    writer.u16(20)
+    writer.u16(FLAG_UTF8)
+    writer.u16(0)
+    writer.u16(DOS_EPOCH_TIME)
+    writer.u16(DOS_EPOCH_DATE)
+    writer.u32(entry.crc)
+    writer.u32(entry.data.length)
+    writer.u32(entry.data.length)
+    writer.u16(entry.nameBytes.length)
+    writer.u16(0)
+    writer.raw(entry.nameBytes)
+    writer.raw(entry.data)
+  }
+
+  for (const entry of staged) {
+    writer.u32(0x02_01_4B_50)
+    writer.u16(20)
+    writer.u16(20)
+    writer.u16(FLAG_UTF8)
+    writer.u16(0)
+    writer.u16(DOS_EPOCH_TIME)
+    writer.u16(DOS_EPOCH_DATE)
+    writer.u32(entry.crc)
+    writer.u32(entry.data.length)
+    writer.u32(entry.data.length)
+    writer.u16(entry.nameBytes.length)
+    writer.u16(0)
+    writer.u16(0)
+    writer.u16(0)
+    writer.u16(0)
+    writer.u32(0)
+    writer.u32(entry.offset)
+    writer.raw(entry.nameBytes)
+  }
+
+  writer.u32(0x06_05_4B_50)
+  writer.u16(0)
+  writer.u16(0)
+  writer.u16(staged.length)
+  writer.u16(staged.length)
+  writer.u32(centralDirectorySize)
+  writer.u32(centralDirectoryOffset)
+  writer.u16(0)
+
+  return writer.result()
+}

package/src/base-component.d.ts

@@ -1,19 +0,0 @@
-// Hand-written types for the vendored base-component.js (see the provenance header there)
-import Config from './util/config.js'
-
-export default class BaseComponent extends Config {
-  constructor(element: Element | string, config?: unknown)
-
-  _element: HTMLElement
-  _config: any
-
-  dispose(): void
-  _queueCallback(callback: () => void, element: Element, isAnimated?: boolean): void
-
-  static getInstance(element: Element | string | null): any
-  static getOrCreateInstance(element: Element | string, config?: unknown): any
-  static get VERSION(): string
-  static get DATA_KEY(): string
-  static get EVENT_KEY(): string
-  static eventName(name: string): string
-}

package/src/dom/event-handler.d.ts

@@ -1,11 +0,0 @@
-// Hand-written types for the vendored event-handler.js (see the provenance header there)
-type EventHandlerFunction = (event: Event & Record<string, unknown>) => void
-
-declare const EventHandler: {
-  on(element: Element | Document | Window, event: string, handler: string | EventHandlerFunction, delegationFunction?: EventHandlerFunction): void
-  one(element: Element | Document | Window, event: string, handler: string | EventHandlerFunction, delegationFunction?: EventHandlerFunction): void
-  off(element: Element | Document | Window, originalTypeEvent: string, handler?: string | EventHandlerFunction, delegationFunction?: EventHandlerFunction): void
-  trigger(element: Element | Document | Window, event: string, args?: Record<string, unknown>): (Event & Record<string, unknown>) | null
-}
-
-export default EventHandler