@reactorui/datagrid 1.0.0

package/dist/utils/index.js

@@ -0,0 +1,209 @@
+// Data formatting utilities (keeping existing ones)
+export const formatters = {
+    date: (value, includeTime = false) => {
+        if (!value)
+            return '';
+        const date = new Date(value);
+        return includeTime ? date.toLocaleString() : date.toLocaleDateString();
+    },
+    currency: (value, currency = 'USD') => {
+        return new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency,
+        }).format(value);
+    },
+    number: (value, decimals = 0) => {
+        return new Intl.NumberFormat('en-US', {
+            minimumFractionDigits: decimals,
+            maximumFractionDigits: decimals,
+        }).format(value);
+    },
+    truncate: (text, length) => {
+        if (!text || text.length <= length)
+            return text;
+        return text.substring(0, length) + '...';
+    },
+};
+// Filter comparison functions (keeping existing implementation)
+export const compareValues = (dataValue, filterValue, operator, dataType) => {
+    if (dataValue == null)
+        return false;
+    switch (dataType) {
+        case 'string':
+            const str = dataValue.toString().toLowerCase();
+            const filter = filterValue.toString().toLowerCase();
+            switch (operator) {
+                case 'eq':
+                    return str === filter;
+                case 'contains':
+                    return str.includes(filter);
+                case 'startsWith':
+                    return str.startsWith(filter);
+                case 'endsWith':
+                    return str.endsWith(filter);
+                default:
+                    return str.includes(filter);
+            }
+        case 'number':
+            const num = parseFloat(dataValue);
+            const filterNum = parseFloat(filterValue);
+            switch (operator) {
+                case 'eq':
+                    return num === filterNum;
+                case 'gt':
+                    return num > filterNum;
+                case 'gte':
+                    return num >= filterNum;
+                case 'lt':
+                    return num < filterNum;
+                case 'lte':
+                    return num <= filterNum;
+                default:
+                    return num === filterNum;
+            }
+        case 'date':
+        case 'datetime':
+            const date = new Date(dataValue).getTime();
+            const filterDate = new Date(filterValue).getTime();
+            switch (operator) {
+                case 'eq':
+                    return date === filterDate;
+                case 'gt':
+                    return date > filterDate;
+                case 'gte':
+                    return date >= filterDate;
+                case 'lt':
+                    return date < filterDate;
+                case 'lte':
+                    return date <= filterDate;
+                default:
+                    return date === filterDate;
+            }
+        case 'boolean':
+            return Boolean(dataValue) === Boolean(filterValue);
+        default:
+            return String(dataValue).toLowerCase().includes(String(filterValue).toLowerCase());
+    }
+};
+// Simplified API utilities
+export const createApiRequest = async (endpoint, request, config = {}) => {
+    const { method = 'GET', bearerToken, apiKey, customHeaders = {}, withCredentials = false, timeout = 30000, } = config;
+    // Build headers
+    const headers = {
+        'Content-Type': 'application/json',
+        ...customHeaders,
+    };
+    if (bearerToken) {
+        headers.Authorization = `Bearer ${bearerToken}`;
+    }
+    if (apiKey) {
+        headers['X-API-Key'] = apiKey;
+    }
+    // Build request
+    const requestOptions = {
+        method,
+        headers,
+        credentials: withCredentials ? 'include' : 'same-origin',
+    };
+    let url = endpoint;
+    if (method === 'POST') {
+        requestOptions.body = JSON.stringify({ request });
+    }
+    else {
+        const params = new URLSearchParams({ request: JSON.stringify(request) });
+        url = `${endpoint}?${params.toString()}`;
+    }
+    // Create timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    requestOptions.signal = controller.signal;
+    try {
+        const response = await fetch(url, requestOptions);
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return mapServerResponse(data);
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+};
+// Simplified server response mapping with flexible casing
+export const mapServerResponse = (data) => {
+    // Helper to get value with flexible casing
+    const getValue = (obj, keys) => {
+        for (const key of keys) {
+            if (obj[key] !== undefined)
+                return obj[key];
+        }
+        return undefined;
+    };
+    // Get items with flexible casing
+    const items = getValue(data, ['Items', 'items', 'data', 'Data']);
+    // Get continuation token with flexible casing
+    const continuationToken = getValue(data, [
+        'ContinuationToken',
+        'continuationToken',
+        'continuationtoken',
+        'nextToken',
+        'next_token',
+        'NextToken',
+    ]);
+    // Get hasMore with flexible casing
+    const hasMore = getValue(data, [
+        'HasMore',
+        'hasMore',
+        'hasmore',
+        'has_more',
+        'hasNextPage',
+        'has_next_page',
+    ]);
+    // Get count with flexible casing
+    const count = getValue(data, ['Count', 'count', 'COUNT', 'total', 'Total', 'length', 'size']);
+    // Direct mapping for arrays
+    if (Array.isArray(data)) {
+        return {
+            Items: data,
+            HasMore: false,
+            Count: data.length,
+        };
+    }
+    // AWS DynamoDB style response (special case)
+    if (data.Items && data.LastEvaluatedKey) {
+        return {
+            Items: data.Items,
+            ContinuationToken: JSON.stringify(data.LastEvaluatedKey),
+            HasMore: !!data.LastEvaluatedKey,
+            Count: data.Count || data.Items.length,
+        };
+    }
+    // Standard response mapping
+    return {
+        Items: Array.isArray(items) ? items : [],
+        ContinuationToken: continuationToken,
+        HasMore: Boolean(hasMore),
+        Count: Number(count) || 0,
+    };
+};
+// Sorting utilities (keeping existing implementation)
+export const sortData = (data, sortColumn, direction) => {
+    if (!sortColumn)
+        return data;
+    return [...data].sort((a, b) => {
+        const aVal = a[sortColumn];
+        const bVal = b[sortColumn];
+        if (aVal == null && bVal == null)
+            return 0;
+        if (aVal == null)
+            return 1;
+        if (bVal == null)
+            return -1;
+        const aStr = String(aVal).toLowerCase();
+        const bStr = String(bVal).toLowerCase();
+        const result = aStr.localeCompare(bStr, undefined, { numeric: true });
+        return direction === 'desc' ? -result : result;
+    });
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@reactorui/datagrid",
+  "version": "1.0.0",
+  "description": "High-performance React data grid with TypeScript support, server-side integration, and continuation token pagination",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "build:rollup": "npm run clean && rollup -c",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "echo 'Linting skipped for now'",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "keywords": [
+    "react",
+    "datagrid",
+    "table",
+    "data-table",
+    "grid",
+    "reactor",
+    "typescript",
+    "performance",
+    "pagination",
+    "continuation-token",
+    "server-side",
+    "filtering",
+    "sorting"
+  ],
+  "author": "ReactorUI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reactorui/datagrid.git"
+  },
+  "bugs": {
+    "url": "https://github.com/reactorui/datagrid/issues"
+  },
+  "homepage": "https://reactorui.dev",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.5",
+    "@testing-library/jest-dom": "^6.1.5",
+    "@testing-library/react": "^13.4.0",
+    "@testing-library/user-event": "^14.5.1",
+    "@types/jest": "^29.5.8",
+    "@types/node": "^20.10.5",
+    "@types/react": "^18.2.45",
+    "@types/react-dom": "^18.2.18",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "prettier": "^3.1.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rollup": "^4.9.1",
+    "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}