react-auto-smart-table 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1218 @@
+// src/analyzer/detectTypes.ts
+var EMAIL_REGEX = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
+var URL_REGEX = /^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6}\.?)(\/[\w.-]*)*\/?$/i;
+var IMAGE_REGEX = /\.(jpeg|jpg|gif|png|webp|svg|bmp)(\?.*)?$/i;
+var isEmail = (value) => EMAIL_REGEX.test(value);
+var isImage = (value) => {
+  return URL_REGEX.test(value) && IMAGE_REGEX.test(value);
+};
+var isUrl = (value) => {
+  if (isImage(value)) return false;
+  return URL_REGEX.test(value);
+};
+var isDate = (value) => {
+  if (value instanceof Date) return !isNaN(value.getTime());
+  if (typeof value === "string" || typeof value === "number") {
+    if (typeof value === "number") return false;
+    if (typeof value === "string" && value.trim() !== "" && !isNaN(Number(value))) return false;
+    const datePattern = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?Z?)?$|^\d{1,2}[-/]\d{1,2}[-/]\d{2,4}$/;
+    if (typeof value === "string" && !datePattern.test(value.trim())) {
+      return false;
+    }
+    const d = new Date(value);
+    return !isNaN(d.getTime()) && String(d) !== "Invalid Date";
+  }
+  return false;
+};
+var isCurrency = (value) => {
+  return typeof value === "string" && /^[£$€¥]?\s*-?\d+(?:,\d{3})*(?:\.\d+)?\s*[£$€¥]?$/.test(value) && /[£$€¥]/.test(value);
+};
+var isPercentage = (value) => {
+  return typeof value === "string" && /^-?\d+(?:\.\d+)?%$/.test(value);
+};
+var isNumber = (value) => {
+  if (typeof value === "number") return true;
+  if (typeof value === "string") {
+    return value.trim() !== "" && !isNaN(Number(value));
+  }
+  return false;
+};
+var isBoolean = (value) => {
+  if (typeof value === "boolean") return true;
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    return lower === "true" || lower === "false" || lower === "yes" || lower === "no";
+  }
+  return false;
+};
+var detectValueType = (value) => {
+  if (value === null || value === void 0 || value === "") return "string";
+  const strVal = String(value);
+  if (isEmail(strVal)) return "email";
+  if (isUrl(strVal)) return "url";
+  if (isImage(strVal)) return "image";
+  if (isDate(value)) return "date";
+  if (isCurrency(strVal)) return "currency";
+  if (isPercentage(strVal)) return "percentage";
+  if (isNumber(value)) return "number";
+  if (isBoolean(value)) return "boolean";
+  return "string";
+};
+
+// src/analyzer/sampleDataset.ts
+function sampleDataset(dataset, maxSampleSize = 200) {
+  if (!dataset || !dataset.length) return [];
+  if (dataset.length <= maxSampleSize) return [...dataset];
+  const sample = [];
+  const indices = /* @__PURE__ */ new Set();
+  while (sample.length < maxSampleSize) {
+    const idx = Math.floor(Math.random() * dataset.length);
+    if (!indices.has(idx)) {
+      indices.add(idx);
+      sample.push(dataset[idx]);
+    }
+  }
+  return sample;
+}
+
+// src/analyzer/computeStats.ts
+var computeColumnStats = (columnKey, dataset, type) => {
+  const stats = {};
+  const uniqueVals = /* @__PURE__ */ new Set();
+  let min = void 0;
+  let max = void 0;
+  for (const row of dataset) {
+    const val = row[columnKey];
+    if (val !== null && val !== void 0 && val !== "") {
+      uniqueVals.add(val);
+      if (type === "number" || type === "currency" || type === "percentage") {
+        let numVal = NaN;
+        if (type === "number") numVal = Number(val);
+        else if (type === "currency" || type === "percentage") {
+          const clean = String(val).replace(/[^0-9.-]/g, "");
+          numVal = Number(clean);
+        }
+        if (!isNaN(numVal)) {
+          if (min === void 0 || numVal < min) min = numVal;
+          if (max === void 0 || numVal > max) max = numVal;
+        }
+      } else if (type === "date") {
+        const d = new Date(val).getTime();
+        if (!isNaN(d)) {
+          if (min === void 0 || d < min) min = d;
+          if (max === void 0 || d > max) max = d;
+        }
+      }
+    }
+  }
+  stats.uniqueValues = uniqueVals.size;
+  if (min !== void 0) stats.min = min;
+  if (max !== void 0) stats.max = max;
+  return stats;
+};
+
+// src/schema/buildSchema.ts
+var buildSchema = (dataset, registry) => {
+  if (!dataset || dataset.length === 0) return {};
+  const sample = sampleDataset(dataset, 200);
+  const sampleSize = sample.length;
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of sample) {
+    for (const key of Object.keys(row)) {
+      keys.add(key);
+    }
+  }
+  const schema = {};
+  for (const key of keys) {
+    const values = sample.map((row) => row[key]);
+    let detectedTypeStr = null;
+    if (registry) {
+      detectedTypeStr = registry.runDetectors(key, values);
+    }
+    if (detectedTypeStr) {
+      const isNull = values.some((v) => v === null || v === void 0);
+      schema[key] = {
+        key,
+        type: detectedTypeStr,
+        nullable: isNull
+      };
+      const stats2 = computeColumnStats(key, sample, detectedTypeStr);
+      schema[key].uniqueValues = stats2.uniqueValues;
+      if (stats2.min !== void 0) schema[key].min = stats2.min;
+      if (stats2.max !== void 0) schema[key].max = stats2.max;
+      continue;
+    }
+    let nullCount = 0;
+    const typeCounts = {};
+    for (const row of sample) {
+      const val = row[key];
+      if (val === null || val === void 0 || val === "") {
+        nullCount++;
+      } else {
+        const detectedType = detectValueType(val);
+        typeCounts[detectedType] = (typeCounts[detectedType] || 0) + 1;
+      }
+    }
+    const validValuesCount = sampleSize - nullCount;
+    let dominantType = "string";
+    if (validValuesCount > 0) {
+      let maxCount = 0;
+      let topType = "string";
+      for (const [type, count] of Object.entries(typeCounts)) {
+        if (count > maxCount) {
+          maxCount = count;
+          topType = type;
+        }
+      }
+      const confidence = maxCount / validValuesCount;
+      dominantType = confidence > 0.7 ? topType : "string";
+    }
+    const stats = computeColumnStats(key, sample, dominantType);
+    const columnSchema = {
+      key,
+      type: dominantType,
+      nullable: nullCount > 0,
+      uniqueValues: stats.uniqueValues
+    };
+    if (stats.min !== void 0) columnSchema.min = stats.min;
+    if (stats.max !== void 0) columnSchema.max = stats.max;
+    schema[key] = columnSchema;
+  }
+  return schema;
+};
+
+// src/hooks/useSorting.ts
+import { useState, useMemo } from "react";
+var useSorting = (data, schema, initialSortColumn = null, initialSortDirection = "asc") => {
+  const [sortColumn, setSortColumn] = useState(initialSortColumn);
+  const [sortDirection, setSortDirection] = useState(initialSortDirection);
+  const handleSort = (columnKey) => {
+    if (sortColumn === columnKey) {
+      if (sortDirection === "asc") {
+        setSortDirection("desc");
+      } else {
+        setSortColumn(null);
+        setSortDirection("asc");
+      }
+    } else {
+      setSortColumn(columnKey);
+      setSortDirection("asc");
+    }
+  };
+  const sortedData = useMemo(() => {
+    if (!sortColumn || !data || data.length === 0) return data;
+    const columnType = schema[sortColumn]?.type || "string";
+    return [...data].sort((a, b) => {
+      let valA = a[sortColumn];
+      let valB = b[sortColumn];
+      if (valA === valB) return 0;
+      if (valA === null || valA === void 0) return sortDirection === "asc" ? 1 : -1;
+      if (valB === null || valB === void 0) return sortDirection === "asc" ? -1 : 1;
+      let comparison = 0;
+      switch (columnType) {
+        case "number":
+        case "currency":
+        case "percentage":
+          const numA = typeof valA === "number" ? valA : Number(String(valA).replace(/[^0-9.-]/g, ""));
+          const numB = typeof valB === "number" ? valB : Number(String(valB).replace(/[^0-9.-]/g, ""));
+          comparison = (isNaN(numA) ? 0 : numA) - (isNaN(numB) ? 0 : numB);
+          break;
+        case "date":
+          const dateA = new Date(valA).getTime();
+          const dateB = new Date(valB).getTime();
+          comparison = (isNaN(dateA) ? 0 : dateA) - (isNaN(dateB) ? 0 : dateB);
+          break;
+        case "boolean":
+          const boolA = valA === true || String(valA).toLowerCase() === "true" || String(valA).toLowerCase() === "yes" ? 1 : 0;
+          const boolB = valB === true || String(valB).toLowerCase() === "true" || String(valB).toLowerCase() === "yes" ? 1 : 0;
+          comparison = boolA - boolB;
+          break;
+        default:
+          comparison = String(valA).localeCompare(String(valB));
+          break;
+      }
+      return sortDirection === "asc" ? comparison : -comparison;
+    });
+  }, [data, schema, sortColumn, sortDirection]);
+  return { sortedData, sortColumn, sortDirection, handleSort };
+};
+
+// src/hooks/useFilters.ts
+import { useState as useState2, useMemo as useMemo2 } from "react";
+var useFilters = (data, schema) => {
+  const [filters, setFilters] = useState2({});
+  const setFilter = (columnKey, value) => {
+    setFilters((prev) => {
+      const next = { ...prev };
+      if (value === null || value === void 0 || value === "") {
+        delete next[columnKey];
+      } else {
+        next[columnKey] = value;
+      }
+      return next;
+    });
+  };
+  const clearFilters = () => setFilters({});
+  const filteredData = useMemo2(() => {
+    if (!filters || Object.keys(filters).length === 0 || !data || data.length === 0) {
+      return data;
+    }
+    return data.filter((row) => {
+      for (const [key, filterValue] of Object.entries(filters)) {
+        const rowValue = row[key];
+        const type = schema[key]?.type || "string";
+        if (rowValue === null || rowValue === void 0) {
+          if (filterValue !== null && filterValue !== "") return false;
+          continue;
+        }
+        switch (type) {
+          case "string":
+          case "email":
+          case "url":
+            if (typeof filterValue === "string") {
+              if (!String(rowValue).toLowerCase().includes(filterValue.toLowerCase())) return false;
+            }
+            break;
+          case "number":
+          case "currency":
+          case "percentage":
+            if (typeof filterValue === "object" && filterValue !== null) {
+              const numVal = typeof rowValue === "number" ? rowValue : Number(String(rowValue).replace(/[^0-9.-]/g, ""));
+              if (isNaN(numVal)) return false;
+              const { min, max } = filterValue;
+              if (min !== void 0 && numVal < min) return false;
+              if (max !== void 0 && numVal > max) return false;
+            }
+            break;
+          case "date":
+            if (typeof filterValue === "object" && filterValue !== null) {
+              const dateVal = new Date(rowValue).getTime();
+              if (isNaN(dateVal)) return false;
+              const { start, end } = filterValue;
+              if (start && dateVal < new Date(start).getTime()) return false;
+              if (end && dateVal > new Date(end).getTime()) return false;
+            }
+            break;
+          case "boolean":
+            if (typeof filterValue === "boolean") {
+              const boolVal = rowValue === true || String(rowValue).toLowerCase() === "true" || String(rowValue).toLowerCase() === "yes";
+              if (boolVal !== filterValue) return false;
+            }
+            break;
+        }
+      }
+      return true;
+    });
+  }, [data, schema, filters]);
+  return { filteredData, filters, setFilter, clearFilters };
+};
+
+// src/hooks/usePagination.ts
+import { useState as useState3, useMemo as useMemo3 } from "react";
+var usePagination = (data, initialPageSize = 10) => {
+  const [currentPage, setCurrentPage] = useState3(1);
+  const [pageSize, setPageSize] = useState3(initialPageSize);
+  const totalPages = Math.max(1, Math.ceil(data.length / pageSize));
+  const safeCurrentPage = Math.min(currentPage, totalPages);
+  const paginatedData = useMemo3(() => {
+    const startIndex = (safeCurrentPage - 1) * pageSize;
+    return data.slice(startIndex, startIndex + pageSize);
+  }, [data, safeCurrentPage, pageSize]);
+  return {
+    paginatedData,
+    currentPage: safeCurrentPage,
+    pageSize,
+    totalPages,
+    setPage: setCurrentPage,
+    setPageSize
+  };
+};
+
+// src/insights/aggregationEngine.ts
+var aggregateData = (dataset, dimension, metrics) => {
+  if (!dataset || dataset.length === 0) return [];
+  if (!dimension) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of dataset) {
+    let dimValue = row[dimension];
+    if (dimValue === null || dimValue === void 0) {
+      dimValue = "Unknown";
+    } else if (typeof dimValue === "boolean") {
+      dimValue = dimValue ? "Yes" : "No";
+    }
+    if (!groups.has(dimValue)) {
+      const initPoint = { [dimension]: dimValue };
+      for (const m of metrics) {
+        initPoint[m] = 0;
+      }
+      groups.set(dimValue, initPoint);
+    }
+    const group = groups.get(dimValue);
+    for (const m of metrics) {
+      const val = row[m];
+      let numVal = 0;
+      if (typeof val === "number") {
+        numVal = val;
+      } else if (typeof val === "string") {
+        numVal = Number(val.replace(/[^0-9.-]/g, ""));
+      }
+      if (!isNaN(numVal)) {
+        group[m] += numVal;
+      }
+    }
+  }
+  return Array.from(groups.values());
+};
+var aggregateDataByCount = (dataset, dimension) => {
+  if (!dataset || dataset.length === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of dataset) {
+    let dimValue = row[dimension];
+    if (dimValue === null || dimValue === void 0) {
+      dimValue = "Unknown";
+    } else if (typeof dimValue === "boolean") {
+      dimValue = dimValue ? "Yes" : "No";
+    }
+    groups.set(dimValue, (groups.get(dimValue) || 0) + 1);
+  }
+  return Array.from(groups.entries()).map(([dim, count]) => ({
+    [dimension]: dim,
+    count
+  }));
+};
+
+// src/insights/chartDetector.ts
+var detectChartFields = (schema) => {
+  const dimensions = [];
+  const metrics = [];
+  for (const [key, col] of Object.entries(schema)) {
+    const lowerKey = key.toLowerCase();
+    const isIdField = lowerKey === "id" || lowerKey === "_id" || lowerKey === "uuid" || lowerKey === "guid" || lowerKey.endsWith("id") || lowerKey.endsWith("_id") || lowerKey.endsWith("uuid");
+    if (isIdField) {
+      continue;
+    }
+    const role = determineFieldRole(col.type, col.uniqueValues);
+    if (role === "dimension") {
+      dimensions.push(key);
+    } else if (role === "metric") {
+      metrics.push(key);
+    }
+  }
+  return { dimensions, metrics };
+};
+var determineFieldRole = (type, uniqueValues) => {
+  switch (type) {
+    case "boolean":
+      return "dimension";
+    case "string":
+      if (uniqueValues !== void 0 && uniqueValues > 1 && uniqueValues <= 20) {
+        return "dimension";
+      }
+      return "discard";
+    case "date":
+      return "dimension";
+    case "number":
+    case "currency":
+    case "percentage":
+      return "metric";
+    default:
+      return "discard";
+  }
+};
+
+// src/utils/stringUtils.ts
+var ACRONYMS = ["ID", "URL", "API", "JSON", "UUID", "SKU", "IP", "VAT", "GST"];
+var toTitleCase = (str) => {
+  if (!str) return "";
+  const spaced = str.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").trim();
+  return spaced.split(" ").filter(Boolean).map((word) => {
+    const upper = word.toUpperCase();
+    if (ACRONYMS.includes(upper)) {
+      return upper;
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }).join(" ");
+};
+
+// src/insights/insightBuilder.ts
+var generateInsights = (dataset, schema) => {
+  if (!dataset || dataset.length === 0 || !schema) return [];
+  const { dimensions, metrics } = detectChartFields(schema);
+  const widgets = [];
+  const maxCharts = 4;
+  if (dimensions.length > 0 && metrics.length > 0) {
+    for (const dim of dimensions) {
+      if (widgets.length >= maxCharts) break;
+      const dimInfo = schema[dim];
+      const targetMetrics = metrics.slice(0, 2);
+      const aggregated = aggregateData(dataset, dim, targetMetrics);
+      if (dimInfo.type === "date") {
+        aggregated.sort((a, b) => new Date(a[dim]).getTime() - new Date(b[dim]).getTime());
+      } else {
+        const primaryMetric = targetMetrics[0];
+        aggregated.sort((a, b) => (b[primaryMetric] || 0) - (a[primaryMetric] || 0));
+      }
+      const isLine = dimInfo.type === "date";
+      const isPie = !isLine && aggregated.length > 0 && aggregated.length <= 5 && targetMetrics.length === 1;
+      widgets.push({
+        id: `chart-${dim}-metrics`,
+        title: `${targetMetrics.map(toTitleCase).join(" & ")} by ${toTitleCase(dim)}`,
+        type: isPie ? "pie" : isLine ? "line" : "bar",
+        data: aggregated,
+        xAxisKey: dim,
+        yAxisKeys: targetMetrics
+      });
+    }
+  }
+  if (dimensions.length > 0 && widgets.length < maxCharts) {
+    for (const dim of dimensions) {
+      if (widgets.length >= maxCharts) break;
+      if (widgets.some((w) => w.id.includes(dim))) continue;
+      const dimInfo = schema[dim];
+      const aggregated = aggregateDataByCount(dataset, dim);
+      if (dimInfo.type === "date") {
+        aggregated.sort((a, b) => new Date(a[dim]).getTime() - new Date(b[dim]).getTime());
+      } else {
+        aggregated.sort((a, b) => b.count - a.count);
+      }
+      const isLine = dimInfo.type === "date";
+      widgets.push({
+        id: `chart-${dim}-count`,
+        title: `Distribution of ${toTitleCase(dim)}`,
+        type: isLine ? "line" : aggregated.length <= 6 ? "pie" : "bar",
+        data: aggregated,
+        xAxisKey: dim,
+        yAxisKeys: ["count"]
+      });
+    }
+  }
+  return widgets;
+};
+
+// src/components/SmartTable.tsx
+import React3, { useMemo as useMemo5 } from "react";
+
+// src/components/TableHeader.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var getColumnWidthClass = (key, type) => {
+  const lowerKey = key.toLowerCase();
+  if (lowerKey === "id" || lowerKey === "_id" || type === "boolean") return "rst-col-xs";
+  if (type === "date" || type === "number" || lowerKey.includes("status")) return "rst-col-sm";
+  if (lowerKey.includes("role") || lowerKey.includes("country") || lowerKey.includes("category")) return "rst-col-md";
+  if (lowerKey.includes("name") || lowerKey.includes("email") || lowerKey.includes("url") || lowerKey.includes("description")) return "rst-col-flex";
+  return "rst-col-md";
+};
+var TableHeader = ({
+  schema,
+  sortable = false,
+  sortColumn = null,
+  sortDirection = "asc",
+  onSort
+}) => {
+  const columns = Object.keys(schema);
+  return /* @__PURE__ */ jsx("thead", { className: "rst-header", children: /* @__PURE__ */ jsx("tr", { className: "rst-header-row", children: columns.map((colKey) => {
+    const colInfo = schema[colKey];
+    const widthClass = getColumnWidthClass(colKey, colInfo.type);
+    return /* @__PURE__ */ jsx(
+      "th",
+      {
+        className: `rst-th rst-th-col-${colKey} rst-th-type-${colInfo.type} ${widthClass} ${sortable && onSort ? "rst-sortable" : ""} ${sortColumn === colKey ? "rst-sort-active" : ""}`,
+        onClick: () => {
+          if (sortable && onSort) onSort(colKey);
+        },
+        children: /* @__PURE__ */ jsxs("div", { className: "rst-header-content", children: [
+          /* @__PURE__ */ jsx("span", { children: toTitleCase(colKey) }),
+          sortable && onSort && /* @__PURE__ */ jsx("span", { className: "rst-sort-icon", children: sortColumn === colKey ? sortDirection === "asc" ? "\u2191" : "\u2193" : "\u21C5" })
+        ] })
+      },
+      colKey
+    );
+  }) }) });
+};
+
+// src/components/TableBody.tsx
+import React, { useRef } from "react";
+
+// src/renderers/numberRenderer.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var NumberRenderer = ({ value }) => {
+  if (value === null || value === void 0) return null;
+  const num = Number(value);
+  if (!isNaN(num)) {
+    return /* @__PURE__ */ jsx2("span", { className: "rst-cell-number", children: new Intl.NumberFormat().format(num) });
+  }
+  return /* @__PURE__ */ jsx2("span", { className: "rst-cell-number", children: String(value) });
+};
+
+// src/renderers/emailRenderer.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var EmailRenderer = ({ value }) => {
+  if (!value) return null;
+  const email = String(value);
+  return /* @__PURE__ */ jsx3("a", { href: `mailto:${email}`, className: "rst-cell-email", onClick: (e) => e.stopPropagation(), children: email });
+};
+
+// src/renderers/urlRenderer.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var UrlRenderer = ({ value }) => {
+  if (!value) return null;
+  const url = String(value);
+  const href = /^https?:\/\//i.test(url) ? url : `https://${url}`;
+  return /* @__PURE__ */ jsx4(
+    "a",
+    {
+      href,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      className: "rst-cell-url",
+      onClick: (e) => e.stopPropagation(),
+      children: url
+    }
+  );
+};
+
+// src/renderers/imageRenderer.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ImageRenderer = ({ value }) => {
+  if (!value) return null;
+  const src = String(value);
+  return /* @__PURE__ */ jsx5(
+    "img",
+    {
+      src,
+      alt: "cell content",
+      className: "rst-cell-image",
+      style: { maxWidth: "50px", maxHeight: "50px", objectFit: "contain", borderRadius: "4px" },
+      loading: "lazy"
+    }
+  );
+};
+
+// src/renderers/percentageRenderer.tsx
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var PercentageRenderer = ({ value }) => {
+  if (value === null || value === void 0) return null;
+  const str = String(value);
+  if (str.includes("%")) {
+    return /* @__PURE__ */ jsx6("span", { className: "rst-cell-percentage", children: str });
+  }
+  const num = Number(value);
+  if (!isNaN(num)) {
+    return /* @__PURE__ */ jsxs2("span", { className: "rst-cell-percentage", children: [
+      (num * 100).toFixed(2),
+      "%"
+    ] });
+  }
+  return /* @__PURE__ */ jsx6("span", { className: "rst-cell-percentage", children: str });
+};
+
+// src/renderers/dateRenderer.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var DateRenderer = ({ value }) => {
+  if (!value) return null;
+  const d = new Date(value);
+  if (isNaN(d.getTime())) {
+    return /* @__PURE__ */ jsx7("span", { className: "rst-cell-date", children: String(value) });
+  }
+  return /* @__PURE__ */ jsx7("span", { className: "rst-cell-date", title: d.toISOString(), children: d.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  }) });
+};
+
+// src/renderers/booleanRenderer.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var BooleanRenderer = ({ value }) => {
+  if (value === null || value === void 0) return null;
+  let isTrue = false;
+  if (typeof value === "boolean") {
+    isTrue = value;
+  } else if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    isTrue = lower === "true" || lower === "yes";
+  } else if (typeof value === "number") {
+    isTrue = value > 0;
+  }
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      className: `rst-cell-boolean rst-cell-boolean-${isTrue ? "true" : "false"}`,
+      style: {
+        display: "inline-block",
+        padding: "2px 8px",
+        borderRadius: "12px",
+        fontSize: "0.85em",
+        fontWeight: "bold",
+        backgroundColor: isTrue ? "#e6f4ea" : "#fce8e6",
+        color: isTrue ? "#137333" : "#c5221f"
+      },
+      children: isTrue ? "Yes" : "No"
+    }
+  );
+};
+
+// src/renderers/defaultRenderer.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var DefaultRenderer = ({ value }) => {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "object") {
+    return /* @__PURE__ */ jsx9("span", { className: "rst-cell-default", children: JSON.stringify(value) });
+  }
+  return /* @__PURE__ */ jsx9("span", { className: "rst-cell-default", children: String(value) });
+};
+
+// src/plugins/currencyPlugin.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var currencyPlugin = {
+  detect: (columnKey, sample) => {
+    const lowerKey = columnKey.toLowerCase();
+    if (lowerKey.includes("amount") || lowerKey.includes("price") || lowerKey.includes("revenue")) {
+      return "currency";
+    }
+    return null;
+  },
+  render: ({ value }) => {
+    if (value === null || value === void 0) return null;
+    let num = NaN;
+    if (typeof value === "number") num = value;
+    else if (typeof value === "string") num = Number(value.replace(/[^0-9.-]/g, ""));
+    if (isNaN(num)) return /* @__PURE__ */ jsx10("span", { children: String(value) });
+    const formatted = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD"
+    }).format(num);
+    return /* @__PURE__ */ jsx10("span", { style: { color: num < 0 ? "#d32f2f" : "#388e3c", fontWeight: "bold" }, children: formatted });
+  }
+};
+
+// src/plugins/percentagePlugin.tsx
+import { jsx as jsx11, jsxs as jsxs3 } from "react/jsx-runtime";
+var percentagePlugin = {
+  detect: (columnKey, sample) => {
+    const lowerKey = columnKey.toLowerCase();
+    if (lowerKey.includes("percent") || lowerKey.includes("rate")) {
+      return "percentage";
+    }
+    return null;
+  },
+  render: ({ value }) => {
+    if (value === null || value === void 0) return null;
+    let str = String(value);
+    let num = Number(value);
+    if (!str.includes("%") && !isNaN(num)) {
+      return /* @__PURE__ */ jsxs3("span", { style: {
+        backgroundColor: "#e3f2fd",
+        padding: "2px 6px",
+        borderRadius: "4px",
+        color: "#1565c0",
+        fontSize: "0.9em",
+        fontWeight: 600
+      }, children: [
+        (num * 100).toFixed(1),
+        "%"
+      ] });
+    }
+    return /* @__PURE__ */ jsx11("span", { style: {
+      backgroundColor: "#e3f2fd",
+      padding: "2px 6px",
+      borderRadius: "4px",
+      color: "#1565c0",
+      fontSize: "0.9em",
+      fontWeight: 600
+    }, children: str });
+  }
+};
+
+// src/renderers/cellRendererFactory.ts
+var getCellRenderer = (type, registry) => {
+  if (registry) {
+    for (const plugin of registry.getPlugins()) {
+      if (type === "currency" && plugin.render && (plugin === currencyPlugin || plugin.detect?.("amount", []) === "currency")) {
+        return plugin.render;
+      }
+      if (type === "percentage" && plugin.render && (plugin === percentagePlugin || plugin.detect?.("percentage", []) === "percentage")) {
+        return plugin.render;
+      }
+    }
+  }
+  switch (type) {
+    case "number":
+    case "currency":
+      return NumberRenderer;
+    case "email":
+      return EmailRenderer;
+    case "url":
+      return UrlRenderer;
+    case "image":
+      return ImageRenderer;
+    case "percentage":
+      return PercentageRenderer;
+    case "date":
+      return DateRenderer;
+    case "boolean":
+      return BooleanRenderer;
+    case "string":
+    default:
+      return DefaultRenderer;
+  }
+};
+
+// src/components/TableBody.tsx
+import { useVirtual } from "react-virtual";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var TableBody = ({ data, schema, registry }) => {
+  const columns = Object.keys(schema);
+  const parentRef = useRef(null);
+  const rowVirtualizer = useVirtual({
+    size: data.length,
+    parentRef,
+    estimateSize: React.useCallback(() => 45, []),
+    overscan: 5
+  });
+  const isVirtualized = data.length > 20;
+  if (!isVirtualized) {
+    return /* @__PURE__ */ jsx12("tbody", { className: "rst-body", children: data.map((row, index) => /* @__PURE__ */ jsx12("tr", { className: "rst-row", children: columns.map((colKey) => {
+      const colInfo = schema[colKey];
+      const Renderer = getCellRenderer(colInfo.type, registry);
+      const widthClass = getColumnWidthClass(colKey, colInfo.type);
+      const val = row[colKey];
+      return /* @__PURE__ */ jsx12(
+        "td",
+        {
+          className: `rst-td rst-td-col-${colKey} rst-td-type-${colInfo.type} ${widthClass}`,
+          children: colInfo.type === "boolean" ? /* @__PURE__ */ jsx12("span", { className: `rst-badge ${val ? "rst-badge-yes" : "rst-badge-no"}`, children: val ? "Yes" : "No" }) : /* @__PURE__ */ jsx12(Renderer, { value: val })
+        },
+        colKey
+      );
+    }) }, index)) });
+  }
+  return /* @__PURE__ */ jsx12(
+    "tbody",
+    {
+      className: "rst-body",
+      ref: parentRef,
+      style: {
+        height: `${rowVirtualizer.totalSize}px`,
+        width: "100%",
+        position: "relative"
+      },
+      children: rowVirtualizer.virtualItems.map((virtualRow) => {
+        const row = data[virtualRow.index];
+        return /* @__PURE__ */ jsx12(
+          "tr",
+          {
+            className: "rst-row",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              height: `${virtualRow.size}px`,
+              transform: `translateY(${virtualRow.start}px)`
+            },
+            children: columns.map((colKey) => {
+              const val = row[colKey];
+              const colInfo = schema[colKey];
+              const Renderer = getCellRenderer(colInfo.type, registry);
+              const widthClass = getColumnWidthClass(colKey, colInfo.type);
+              return /* @__PURE__ */ jsx12(
+                "td",
+                {
+                  className: `rst-td rst-td-col-${colKey} rst-td-type-${colInfo.type} ${widthClass}`,
+                  children: colInfo.type === "boolean" ? /* @__PURE__ */ jsx12("span", { className: `rst-badge ${val ? "rst-badge-yes" : "rst-badge-no"}`, children: val ? "Yes" : "No" }) : /* @__PURE__ */ jsx12(Renderer, { value: val })
+                },
+                colKey
+              );
+            })
+          },
+          virtualRow.index
+        );
+      })
+    }
+  );
+};
+
+// src/components/FilterPanel.tsx
+import { jsx as jsx13, jsxs as jsxs4 } from "react/jsx-runtime";
+var FilterPanel = ({ schema, filters, onFilterChange, onClear }) => {
+  const handleStringChange = (key, e) => {
+    onFilterChange(key, e.target.value || null);
+  };
+  const handleNumberChange = (key, field, value) => {
+    const current = filters[key] || {};
+    const num = parseFloat(value);
+    const next = { ...current };
+    if (isNaN(num)) {
+      delete next[field];
+    } else {
+      next[field] = num;
+    }
+    if (Object.keys(next).length === 0) {
+      onFilterChange(key, null);
+    } else {
+      onFilterChange(key, next);
+    }
+  };
+  const handleDateChange = (key, field, value) => {
+    const current = filters[key] || {};
+    const next = { ...current };
+    if (!value) {
+      delete next[field];
+    } else {
+      next[field] = value;
+    }
+    if (Object.keys(next).length === 0) {
+      onFilterChange(key, null);
+    } else {
+      onFilterChange(key, next);
+    }
+  };
+  const handleBooleanToggle = (key) => {
+    const current = filters[key];
+    if (current === true) {
+      onFilterChange(key, false);
+    } else if (current === false) {
+      onFilterChange(key, null);
+    } else {
+      onFilterChange(key, true);
+    }
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: "rst-filter-panel", children: [
+    Object.entries(schema).map(([key, colInfo]) => {
+      const type = colInfo.type;
+      const currentFilter = filters[key];
+      return /* @__PURE__ */ jsxs4("div", { className: `rst-filter-group rst-filter-type-${type}`, children: [
+        /* @__PURE__ */ jsxs4("label", { children: [
+          toTitleCase(key),
+          " Filter"
+        ] }),
+        (type === "string" || type === "email" || type === "url") && /* @__PURE__ */ jsx13(
+          "input",
+          {
+            type: "text",
+            placeholder: `Search ${toTitleCase(key)}...`,
+            value: currentFilter || "",
+            onChange: (e) => handleStringChange(key, e)
+          }
+        ),
+        (type === "number" || type === "currency" || type === "percentage") && /* @__PURE__ */ jsxs4("div", { className: "rst-filter-range", children: [
+          /* @__PURE__ */ jsx13(
+            "input",
+            {
+              type: "number",
+              placeholder: "Min",
+              value: currentFilter?.min ?? "",
+              onChange: (e) => handleNumberChange(key, "min", e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            "input",
+            {
+              type: "number",
+              placeholder: "Max",
+              value: currentFilter?.max ?? "",
+              onChange: (e) => handleNumberChange(key, "max", e.target.value)
+            }
+          )
+        ] }),
+        type === "date" && /* @__PURE__ */ jsxs4("div", { className: "rst-filter-range", children: [
+          /* @__PURE__ */ jsx13(
+            "input",
+            {
+              type: "date",
+              title: "Start Date",
+              value: currentFilter?.start || "",
+              onChange: (e) => handleDateChange(key, "start", e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            "input",
+            {
+              type: "date",
+              title: "End Date",
+              value: currentFilter?.end || "",
+              onChange: (e) => handleDateChange(key, "end", e.target.value)
+            }
+          )
+        ] }),
+        type === "boolean" && /* @__PURE__ */ jsx13(
+          "button",
+          {
+            className: "rst-filter-toggle",
+            onClick: () => handleBooleanToggle(key),
+            style: {
+              backgroundColor: currentFilter === true ? "#e6f4ea" : currentFilter === false ? "#fce8e6" : "#fff"
+            },
+            children: currentFilter === true ? "Only Yes" : currentFilter === false ? "Only No" : "All"
+          }
+        )
+      ] }, key);
+    }),
+    Object.keys(filters).length > 0 && /* @__PURE__ */ jsx13(
+      "button",
+      {
+        className: "rst-filter-clear-btn",
+        onClick: onClear,
+        children: "Clear All Filters"
+      }
+    )
+  ] });
+};
+
+// src/components/InsightsPanel.tsx
+import { useMemo as useMemo4 } from "react";
+import {
+  BarChart,
+  Bar,
+  LineChart,
+  Line,
+  PieChart,
+  Pie,
+  Cell,
+  XAxis,
+  YAxis,
+  CartesianGrid,
+  Tooltip,
+  Legend,
+  ResponsiveContainer
+} from "recharts";
+import { jsx as jsx14, jsxs as jsxs5 } from "react/jsx-runtime";
+var COLORS = ["#8884d8", "#82ca9d", "#ffc658", "#ff8042", "#a4de6c", "#d0ed57"];
+var InsightsPanel = ({ data, schema }) => {
+  const insights = useMemo4(() => {
+    return generateInsights(data, schema);
+  }, [data, schema]);
+  if (!insights || insights.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs5("div", { className: "rst-insights-panel", children: [
+    /* @__PURE__ */ jsx14("h3", { children: "AI Generated Insights" }),
+    /* @__PURE__ */ jsx14("div", { className: "rst-insights-grid", children: insights.map((widget) => /* @__PURE__ */ jsxs5("div", { className: "rst-insight-card", children: [
+      /* @__PURE__ */ jsx14("h4", { className: "rst-insight-title", children: widget.title }),
+      /* @__PURE__ */ jsx14("div", { className: "rst-insight-chart-wrapper", style: { height: "240px" }, children: /* @__PURE__ */ jsx14(ResponsiveContainer, { width: "100%", height: "100%", children: widget.type === "bar" ? /* @__PURE__ */ jsxs5(BarChart, { data: widget.data, margin: { top: 5, right: 10, left: 0, bottom: 5 }, children: [
+        /* @__PURE__ */ jsx14(CartesianGrid, { strokeDasharray: "3 3", vertical: false, stroke: "#e2e8f0" }),
+        /* @__PURE__ */ jsx14(XAxis, { dataKey: widget.xAxisKey, tick: { fontSize: 11, fill: "#64748b" }, axisLine: { stroke: "#e2e8f0" }, tickLine: false }),
+        /* @__PURE__ */ jsx14(YAxis, { tick: { fontSize: 11, fill: "#64748b" }, axisLine: { stroke: "#e2e8f0" }, tickLine: false }),
+        /* @__PURE__ */ jsx14(
+          Tooltip,
+          {
+            contentStyle: { borderRadius: "8px", border: "none", boxShadow: "0 4px 6px -1px rgb(0 0 0 / 0.1)" },
+            cursor: { fill: "#f1f5f9" }
+          }
+        ),
+        /* @__PURE__ */ jsx14(Legend, { wrapperStyle: { fontSize: "11px", paddingTop: "10px" }, iconType: "circle" }),
+        widget.yAxisKeys.map((yKey, index) => /* @__PURE__ */ jsx14(Bar, { dataKey: yKey, fill: COLORS[index % COLORS.length], radius: [4, 4, 0, 0], barSize: 32 }, yKey))
+      ] }) : widget.type === "line" ? /* @__PURE__ */ jsxs5(LineChart, { data: widget.data, margin: { top: 5, right: 10, left: 0, bottom: 5 }, children: [
+        /* @__PURE__ */ jsx14(CartesianGrid, { strokeDasharray: "3 3", vertical: false, stroke: "#e2e8f0" }),
+        /* @__PURE__ */ jsx14(XAxis, { dataKey: widget.xAxisKey, tick: { fontSize: 11, fill: "#64748b" }, axisLine: { stroke: "#e2e8f0" }, tickLine: false }),
+        /* @__PURE__ */ jsx14(YAxis, { tick: { fontSize: 11, fill: "#64748b" }, axisLine: { stroke: "#e2e8f0" }, tickLine: false }),
+        /* @__PURE__ */ jsx14(Tooltip, { contentStyle: { borderRadius: "8px", border: "none", boxShadow: "0 4px 6px -1px rgb(0 0 0 / 0.1)" } }),
+        /* @__PURE__ */ jsx14(Legend, { wrapperStyle: { fontSize: "11px", paddingTop: "10px" }, iconType: "circle" }),
+        widget.yAxisKeys.map((yKey, index) => /* @__PURE__ */ jsx14(Line, { type: "monotone", dataKey: yKey, stroke: COLORS[index % COLORS.length], strokeWidth: 2.5, dot: { r: 4, strokeWidth: 2, fill: "#fff" }, activeDot: { r: 6, strokeWidth: 0 } }, yKey))
+      ] }) : /* @__PURE__ */ jsxs5(PieChart, { children: [
+        /* @__PURE__ */ jsx14(Tooltip, { contentStyle: { borderRadius: "8px", border: "none", boxShadow: "0 4px 6px -1px rgb(0 0 0 / 0.1)" } }),
+        /* @__PURE__ */ jsx14(Legend, { wrapperStyle: { fontSize: "11px" }, iconType: "circle" }),
+        /* @__PURE__ */ jsx14(
+          Pie,
+          {
+            data: widget.data,
+            cx: "50%",
+            cy: "45%",
+            innerRadius: 60,
+            outerRadius: 80,
+            fill: "#8884d8",
+            paddingAngle: 5,
+            dataKey: widget.yAxisKeys[0],
+            nameKey: widget.xAxisKey,
+            label: false,
+            children: widget.data.map((entry, index) => /* @__PURE__ */ jsx14(Cell, { fill: COLORS[index % COLORS.length] }, `cell-${index}`))
+          }
+        )
+      ] }) }) })
+    ] }, widget.id)) })
+  ] });
+};
+
+// src/plugins/pluginRegistry.ts
+var PluginRegistry = class {
+  constructor() {
+    this.plugins = [];
+  }
+  register(pluginOrPlugins) {
+    if (Array.isArray(pluginOrPlugins)) {
+      this.plugins.push(...pluginOrPlugins);
+    } else {
+      this.plugins.push(pluginOrPlugins);
+    }
+  }
+  clear() {
+    this.plugins = [];
+  }
+  runDetectors(columnKey, sample) {
+    for (const plugin of this.plugins) {
+      if (plugin.detect) {
+        const detectedType = plugin.detect(columnKey, sample);
+        if (detectedType) {
+          return detectedType;
+        }
+      }
+    }
+    return null;
+  }
+  getRenderers() {
+    const renderers = {};
+    for (const plugin of this.plugins) {
+    }
+    return renderers;
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+};
+var globalPluginRegistry = new PluginRegistry();
+
+// src/components/SmartTable.tsx
+import { jsx as jsx15, jsxs as jsxs6 } from "react/jsx-runtime";
+var SmartTable = ({
+  data,
+  sortable = false,
+  filterable = false,
+  pagination = false,
+  insights = false,
+  plugins = []
+}) => {
+  const registry = useMemo5(() => {
+    const reg = new PluginRegistry();
+    if (plugins && plugins.length > 0) {
+      reg.register(plugins);
+    }
+    return reg;
+  }, [plugins]);
+  const schema = useMemo5(() => {
+    return buildSchema(data, registry);
+  }, [data, registry]);
+  const { filteredData, filters, setFilter, clearFilters } = useFilters(data, schema);
+  const dataToFilter = filterable ? filteredData : data;
+  const { sortedData, sortColumn, sortDirection, handleSort } = useSorting(dataToFilter, schema);
+  const dataToRenderOrPaginate = sortable ? sortedData : dataToFilter;
+  const { paginatedData, currentPage, totalPages, setPage } = usePagination(dataToRenderOrPaginate, 10);
+  const finalData = pagination ? paginatedData : dataToRenderOrPaginate;
+  const [showFilters, setShowFilters] = React3.useState(true);
+  if (!data || data.length === 0) {
+    return /* @__PURE__ */ jsx15("div", { className: "rst-container", children: /* @__PURE__ */ jsx15("div", { className: "rst-empty", children: "No data to display." }) });
+  }
+  const summaryStats = /* @__PURE__ */ jsxs6("div", { className: "rst-summary-strip", children: [
+    /* @__PURE__ */ jsxs6("span", { children: [
+      data.length,
+      " Records"
+    ] }),
+    /* @__PURE__ */ jsx15("span", { className: "rst-dot", children: "\u2022" }),
+    /* @__PURE__ */ jsxs6("span", { children: [
+      Object.keys(schema).length,
+      " Columns"
+    ] }),
+    /* @__PURE__ */ jsx15("span", { className: "rst-dot", children: "\u2022" }),
+    /* @__PURE__ */ jsxs6("span", { children: [
+      "Types: ",
+      Array.from(new Set(Object.values(schema).map((c) => c.type))).join(", ")
+    ] })
+  ] });
+  return /* @__PURE__ */ jsxs6("div", { className: "rst-container", children: [
+    /* @__PURE__ */ jsx15("header", { className: "rst-main-header", children: /* @__PURE__ */ jsxs6("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "flex-end" }, children: [
+      /* @__PURE__ */ jsxs6("div", { children: [
+        /* @__PURE__ */ jsx15("h2", { children: "Smart Table" }),
+        /* @__PURE__ */ jsx15("p", { children: "Auto-generated insights, filters, and records" })
+      ] }),
+      filterable && /* @__PURE__ */ jsxs6(
+        "button",
+        {
+          className: "rst-toggle-filters-btn",
+          onClick: () => setShowFilters(!showFilters),
+          children: [
+            "Filters ",
+            showFilters ? "\u25B2" : "\u25BC"
+          ]
+        }
+      )
+    ] }) }),
+    insights && /* @__PURE__ */ jsx15(InsightsPanel, { data: dataToRenderOrPaginate, schema }),
+    summaryStats,
+    filterable && showFilters && /* @__PURE__ */ jsx15("section", { className: "rst-card", children: /* @__PURE__ */ jsx15(
+      FilterPanel,
+      {
+        schema,
+        filters,
+        onFilterChange: setFilter,
+        onClear: clearFilters
+      }
+    ) }),
+    data.length > 0 && finalData.length === 0 && /* @__PURE__ */ jsxs6("div", { className: "rst-empty-results-card", children: [
+      /* @__PURE__ */ jsx15("div", { className: "rst-empty-icon", children: "\u{1F50D}" }),
+      /* @__PURE__ */ jsx15("h3", { children: "No results found" }),
+      /* @__PURE__ */ jsx15("p", { children: "Try adjusting your filters to find what you're looking for." }),
+      /* @__PURE__ */ jsx15("button", { className: "btn btn-primary", onClick: clearFilters, children: "Clear All Filters" })
+    ] }),
+    data.length > 0 && finalData.length > 0 && /* @__PURE__ */ jsxs6("section", { className: "rst-card", children: [
+      /* @__PURE__ */ jsx15("div", { className: "rst-table-container", children: /* @__PURE__ */ jsxs6("table", { className: "rst-table", children: [
+        /* @__PURE__ */ jsx15(
+          TableHeader,
+          {
+            schema,
+            sortable,
+            sortColumn,
+            sortDirection,
+            onSort: handleSort
+          }
+        ),
+        /* @__PURE__ */ jsx15(TableBody, { data: finalData, schema, registry })
+      ] }) }),
+      pagination && /* @__PURE__ */ jsxs6("div", { className: "rst-pagination", children: [
+        /* @__PURE__ */ jsx15(
+          "button",
+          {
+            disabled: currentPage === 1,
+            onClick: () => setPage(currentPage - 1),
+            children: "Previous"
+          }
+        ),
+        /* @__PURE__ */ jsxs6("span", { children: [
+          "Page ",
+          currentPage,
+          " of ",
+          totalPages
+        ] }),
+        /* @__PURE__ */ jsx15(
+          "button",
+          {
+            disabled: currentPage === totalPages,
+            onClick: () => setPage(currentPage + 1),
+            children: "Next"
+          }
+        )
+      ] })
+    ] })
+  ] });
+};
+export {
+  FilterPanel,
+  InsightsPanel,
+  PluginRegistry,
+  SmartTable,
+  aggregateData,
+  aggregateDataByCount,
+  buildSchema,
+  computeColumnStats,
+  currencyPlugin,
+  detectChartFields,
+  detectValueType,
+  generateInsights,
+  getCellRenderer,
+  globalPluginRegistry,
+  percentagePlugin,
+  sampleDataset,
+  useFilters,
+  usePagination,
+  useSorting
+};
+//# sourceMappingURL=index.mjs.map