capitalsix-data-table 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DataTable: () => DataTable
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/DataTable.ts
+var DataTable = class {
+  constructor(initialRows = []) {
+    this.rows = [];
+    this.getRows = (predicate) => {
+      return predicate ? this.rows.filter(predicate) : this.rows;
+    };
+    this.setRows = (newRows) => {
+      this.rows.length = 0;
+      this.rows.push(...newRows);
+    };
+    this.insertRows = (newRows, primaryKey) => {
+      if (primaryKey) {
+        if (this.rows.some((row) => newRows.findIndex((r) => r[primaryKey] === row[primaryKey]) !== -1)) {
+          throw new Error(
+            `Duplicate primary key value found in existing rows for key: ${String(primaryKey)}`
+          );
+        }
+      }
+      this.rows.push(...newRows);
+    };
+    this.updateRows = (predicate, update, primaryKey) => {
+      const updatedRows = this.rows.filter(predicate);
+      let updateFunction;
+      if (typeof update === "function") {
+        updateFunction = update;
+      } else if (primaryKey === void 0) {
+        throw new Error("Primary key must be provided when update is an object.");
+      } else {
+        updateFunction = (updateRow) => {
+          Object.assign(updateRow, { ...update, [primaryKey]: updateRow[primaryKey] });
+        };
+      }
+      for (let i = 0; i < this.rows.length; i++) {
+        if (predicate(this.rows[i])) {
+          updateFunction(this.rows[i]);
+        }
+      }
+      return updatedRows;
+    };
+    this.upsertRows = (newRows, primaryKey) => {
+      const result = { inserted: [], updated: [] };
+      const existingRowsMap = new Map(this.rows.map((row) => [row[primaryKey], row]));
+      for (const newRow of newRows) {
+        const key = newRow[primaryKey];
+        if (existingRowsMap.has(key)) {
+          Object.assign(existingRowsMap.get(key), newRow);
+          result.updated.push(newRow);
+        } else {
+          this.rows.push(newRow);
+          result.inserted.push(newRow);
+        }
+      }
+      return result;
+    };
+    this.deleteRows = (predicate) => {
+      const deletedRows = this.rows.filter(predicate);
+      for (let i = this.rows.length - 1; i >= 0; i--) {
+        if (predicate(this.rows[i])) {
+          this.rows.splice(i, 1);
+        }
+      }
+      return deletedRows;
+    };
+    this.sortRows = (compareFn) => {
+      this.rows.sort(compareFn);
+    };
+    this.rows = initialRows;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataTable
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/DataTable.ts"],"sourcesContent":["export { DataTable, type IDataTable } from './DataTable';\n","/**\r\n * Minimal initializer contract for replacing all rows in the table.\r\n */\r\nexport interface IDataTableInitial<T extends object> {\r\n  /**\r\n   * Replaces all current rows with the provided rows.\r\n   */\r\n  setRows: (rows: T[]) => void;\r\n}\r\n\r\n/**\r\n * Result of an upsert operation.\r\n * `inserted` contains rows that did not exist yet.\r\n * `updated` contains rows that matched an existing primary key.\r\n */\r\nexport interface DataTableUpsertResult<T extends object> {\r\n  inserted: T[];\r\n  updated: T[];\r\n}\r\n\r\n/**\r\n * Table-like CRUD and query operations for in-memory rows.\r\n */\r\nexport interface IDataTable<T extends object> {\r\n  /**\r\n   * Returns all rows, or only rows matching the predicate when provided.\r\n   */\r\n  getRows: (predicate?: (row: T) => boolean) => T[];\r\n\r\n  /**\r\n   * Appends rows to the table.\r\n   * When `primaryKey` is provided, the method validates that no incoming key\r\n   * already exists in the current table.\r\n   */\r\n  insertRows: (rows: T[], primaryKey?: keyof T) => void;\r\n\r\n  /**\r\n   * Updates all rows that match `predicate`.\r\n   *\r\n   * - When `update` is a function, the function mutates each matched row.\r\n   * - When `update` is an object, `primaryKey` is required and preserved on each row.\r\n   *\r\n   * Returns the matched rows by reference (already reflecting any applied mutations).\r\n   */\r\n  updateRows: (\r\n    predicate: (row: T) => boolean,\r\n    update: T | ((updateRow: T) => void),\r\n    primaryKey?: keyof T) => T[];\r\n\r\n  /**\r\n   * Upserts rows by `primaryKey`.\r\n   *\r\n   * - If a matching key exists, the existing row is updated in place.\r\n   * - If no matching key exists, the row is inserted.\r\n   *\r\n   * Returns a `DataTableUpsertResult` where:\r\n   * - `updated` contains the incoming rows that matched existing keys.\r\n   * - `inserted` contains the incoming rows that were newly added.\r\n   */\r\n  upsertRows: (rows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;\r\n\r\n  /**\r\n   * Deletes matching rows and returns the deleted rows.\r\n   */\r\n  deleteRows: (predicate: (row: T) => boolean) => T[];\r\n  \r\n  /**\r\n   * Sorts rows in place with the provided compare function.\r\n   */\r\n  sortRows: (compareFn: (a: T, b: T) => number) => void;\r\n}\r\n\r\n/**\r\n * Generic in-memory data table with mutable row operations.\r\n */\r\nexport class DataTable<T extends object> implements IDataTable<T>, IDataTableInitial<T> {\r\n  private rows: T[] = [];\r\n\r\n  public constructor(initialRows: T[] = []) {\r\n    this.rows = initialRows;\r\n  }\r\n\r\n  public getRows = (predicate?: (row: T) => boolean): T[] => {\r\n    return predicate ? this.rows.filter(predicate) : this.rows;\r\n  };\r\n\r\n  public setRows = (newRows: T[]): void => {\r\n    this.rows.length = 0;\r\n    this.rows.push(...newRows);\r\n  };\r\n\r\n  public insertRows = (newRows: T[], primaryKey?: keyof T): void => {\r\n    if (primaryKey) {\r\n      // Reject insert when any incoming row key already exists in the current table.\r\n      if (this.rows.some(row => newRows.findIndex(r => r[primaryKey] === row[primaryKey]) !== -1))\r\n      {\r\n        throw new Error(\r\n          `Duplicate primary key value found in existing rows for key: ${String(primaryKey)}`);\r\n      }\r\n    }\r\n    this.rows.push(...newRows);\r\n  };\r\n\r\n  public updateRows = (\r\n    predicate: (row: T) => boolean,\r\n    update: T | ((updateRow: T) => void),\r\n    primaryKey?: keyof T): T[] => {\r\n    // Keep references to matched rows; these objects are mutated in place below.\r\n    const updatedRows: T[] = this.rows.filter(predicate);\r\n\r\n    let updateFunction: (updateRow: T) => void;\r\n    if (typeof update === 'function') {\r\n      updateFunction = update as (updateRow: T) => void;\r\n    } else if (primaryKey === undefined) {\r\n      throw new Error('Primary key must be provided when update is an object.');\r\n    } else {\r\n      // Preserve the original primary key when doing object-style updates.\r\n      updateFunction = (updateRow: T): void => {\r\n        Object.assign(updateRow, { ...update, [primaryKey!]: updateRow[primaryKey!] });\r\n      };\r\n    }\r\n\r\n    for (let i = 0; i < this.rows.length; i++) {\r\n      if (predicate(this.rows[i])) {\r\n        updateFunction(this.rows[i]);\r\n      }\r\n    }\r\n\r\n    return updatedRows;\r\n  };\r\n\r\n  public upsertRows = (newRows: T[], primaryKey: keyof T): DataTableUpsertResult<T> => {\r\n    const result: DataTableUpsertResult<T> = { inserted: [], updated: [] };\r\n    // Index existing rows by primary key for efficient upsert lookup.\r\n    const existingRowsMap = new Map(this.rows.map(row => [ row[primaryKey], row ]));\r\n    for (const newRow of newRows) {\r\n      const key = newRow[primaryKey];\r\n      if (existingRowsMap.has(key)) {\r\n        Object.assign(existingRowsMap.get(key)!, newRow);\r\n        result.updated.push(newRow);\r\n      } else {\r\n        this.rows.push(newRow);\r\n        result.inserted.push(newRow);\r\n      }\r\n    }\r\n    return result;\r\n  };\r\n\r\n  public deleteRows = (predicate: (row: T) => boolean): T[] => {\r\n    const deletedRows = this.rows.filter(predicate);\r\n\r\n    // Iterate backwards to safely remove items from the same array.\r\n    for (let i = this.rows.length - 1; i >= 0; i--) {\r\n      if (predicate(this.rows[i])) {\r\n        this.rows.splice(i, 1);\r\n      }\r\n    }\r\n\r\n    return deletedRows;\r\n  };\r\n\r\n  public sortRows = (compareFn: (a: T, b: T) => number): void => {\r\n    this.rows.sort(compareFn);\r\n  };\r\n}\r\n\r\nexport default DataTable;\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC2EO,IAAM,YAAN,MAAiF;AAAA,EAG/E,YAAY,cAAmB,CAAC,GAAG;AAF1C,SAAQ,OAAY,CAAC;AAMrB,SAAO,UAAU,CAAC,cAAyC;AACzD,aAAO,YAAY,KAAK,KAAK,OAAO,SAAS,IAAI,KAAK;AAAA,IACxD;AAEA,SAAO,UAAU,CAAC,YAAuB;AACvC,WAAK,KAAK,SAAS;AACnB,WAAK,KAAK,KAAK,GAAG,OAAO;AAAA,IAC3B;AAEA,SAAO,aAAa,CAAC,SAAc,eAA+B;AAChE,UAAI,YAAY;AAEd,YAAI,KAAK,KAAK,KAAK,SAAO,QAAQ,UAAU,OAAK,EAAE,UAAU,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,GAC1F;AACE,gBAAM,IAAI;AAAA,YACR,+DAA+D,OAAO,UAAU,CAAC;AAAA,UAAE;AAAA,QACvF;AAAA,MACF;AACA,WAAK,KAAK,KAAK,GAAG,OAAO;AAAA,IAC3B;AAEA,SAAO,aAAa,CAClB,WACA,QACA,eAA8B;AAE9B,YAAM,cAAmB,KAAK,KAAK,OAAO,SAAS;AAEnD,UAAI;AACJ,UAAI,OAAO,WAAW,YAAY;AAChC,yBAAiB;AAAA,MACnB,WAAW,eAAe,QAAW;AACnC,cAAM,IAAI,MAAM,wDAAwD;AAAA,MAC1E,OAAO;AAEL,yBAAiB,CAAC,cAAuB;AACvC,iBAAO,OAAO,WAAW,EAAE,GAAG,QAAQ,CAAC,UAAW,GAAG,UAAU,UAAW,EAAE,CAAC;AAAA,QAC/E;AAAA,MACF;AAEA,eAAS,IAAI,GAAG,IAAI,KAAK,KAAK,QAAQ,KAAK;AACzC,YAAI,UAAU,KAAK,KAAK,CAAC,CAAC,GAAG;AAC3B,yBAAe,KAAK,KAAK,CAAC,CAAC;AAAA,QAC7B;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,SAAO,aAAa,CAAC,SAAc,eAAkD;AACnF,YAAM,SAAmC,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC,EAAE;AAErE,YAAM,kBAAkB,IAAI,IAAI,KAAK,KAAK,IAAI,SAAO,CAAE,IAAI,UAAU,GAAG,GAAI,CAAC,CAAC;AAC9E,iBAAW,UAAU,SAAS;AAC5B,cAAM,MAAM,OAAO,UAAU;AAC7B,YAAI,gBAAgB,IAAI,GAAG,GAAG;AAC5B,iBAAO,OAAO,gBAAgB,IAAI,GAAG,GAAI,MAAM;AAC/C,iBAAO,QAAQ,KAAK,MAAM;AAAA,QAC5B,OAAO;AACL,eAAK,KAAK,KAAK,MAAM;AACrB,iBAAO,SAAS,KAAK,MAAM;AAAA,QAC7B;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,SAAO,aAAa,CAAC,cAAwC;AAC3D,YAAM,cAAc,KAAK,KAAK,OAAO,SAAS;AAG9C,eAAS,IAAI,KAAK,KAAK,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,YAAI,UAAU,KAAK,KAAK,CAAC,CAAC,GAAG;AAC3B,eAAK,KAAK,OAAO,GAAG,CAAC;AAAA,QACvB;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,SAAO,WAAW,CAAC,cAA4C;AAC7D,WAAK,KAAK,KAAK,SAAS;AAAA,IAC1B;AApFE,SAAK,OAAO;AAAA,EACd;AAoFF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,77 @@
+/**
+ * Minimal initializer contract for replacing all rows in the table.
+ */
+interface IDataTableInitial<T extends object> {
+    /**
+     * Replaces all current rows with the provided rows.
+     */
+    setRows: (rows: T[]) => void;
+}
+/**
+ * Result of an upsert operation.
+ * `inserted` contains rows that did not exist yet.
+ * `updated` contains rows that matched an existing primary key.
+ */
+interface DataTableUpsertResult<T extends object> {
+    inserted: T[];
+    updated: T[];
+}
+/**
+ * Table-like CRUD and query operations for in-memory rows.
+ */
+interface IDataTable<T extends object> {
+    /**
+     * Returns all rows, or only rows matching the predicate when provided.
+     */
+    getRows: (predicate?: (row: T) => boolean) => T[];
+    /**
+     * Appends rows to the table.
+     * When `primaryKey` is provided, the method validates that no incoming key
+     * already exists in the current table.
+     */
+    insertRows: (rows: T[], primaryKey?: keyof T) => void;
+    /**
+     * Updates all rows that match `predicate`.
+     *
+     * - When `update` is a function, the function mutates each matched row.
+     * - When `update` is an object, `primaryKey` is required and preserved on each row.
+     *
+     * Returns the matched rows by reference (already reflecting any applied mutations).
+     */
+    updateRows: (predicate: (row: T) => boolean, update: T | ((updateRow: T) => void), primaryKey?: keyof T) => T[];
+    /**
+     * Upserts rows by `primaryKey`.
+     *
+     * - If a matching key exists, the existing row is updated in place.
+     * - If no matching key exists, the row is inserted.
+     *
+     * Returns a `DataTableUpsertResult` where:
+     * - `updated` contains the incoming rows that matched existing keys.
+     * - `inserted` contains the incoming rows that were newly added.
+     */
+    upsertRows: (rows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;
+    /**
+     * Deletes matching rows and returns the deleted rows.
+     */
+    deleteRows: (predicate: (row: T) => boolean) => T[];
+    /**
+     * Sorts rows in place with the provided compare function.
+     */
+    sortRows: (compareFn: (a: T, b: T) => number) => void;
+}
+/**
+ * Generic in-memory data table with mutable row operations.
+ */
+declare class DataTable<T extends object> implements IDataTable<T>, IDataTableInitial<T> {
+    private rows;
+    constructor(initialRows?: T[]);
+    getRows: (predicate?: (row: T) => boolean) => T[];
+    setRows: (newRows: T[]) => void;
+    insertRows: (newRows: T[], primaryKey?: keyof T) => void;
+    updateRows: (predicate: (row: T) => boolean, update: T | ((updateRow: T) => void), primaryKey?: keyof T) => T[];
+    upsertRows: (newRows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;
+    deleteRows: (predicate: (row: T) => boolean) => T[];
+    sortRows: (compareFn: (a: T, b: T) => number) => void;
+}
+
+export { DataTable, type IDataTable };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Minimal initializer contract for replacing all rows in the table.
+ */
+interface IDataTableInitial<T extends object> {
+    /**
+     * Replaces all current rows with the provided rows.
+     */
+    setRows: (rows: T[]) => void;
+}
+/**
+ * Result of an upsert operation.
+ * `inserted` contains rows that did not exist yet.
+ * `updated` contains rows that matched an existing primary key.
+ */
+interface DataTableUpsertResult<T extends object> {
+    inserted: T[];
+    updated: T[];
+}
+/**
+ * Table-like CRUD and query operations for in-memory rows.
+ */
+interface IDataTable<T extends object> {
+    /**
+     * Returns all rows, or only rows matching the predicate when provided.
+     */
+    getRows: (predicate?: (row: T) => boolean) => T[];
+    /**
+     * Appends rows to the table.
+     * When `primaryKey` is provided, the method validates that no incoming key
+     * already exists in the current table.
+     */
+    insertRows: (rows: T[], primaryKey?: keyof T) => void;
+    /**
+     * Updates all rows that match `predicate`.
+     *
+     * - When `update` is a function, the function mutates each matched row.
+     * - When `update` is an object, `primaryKey` is required and preserved on each row.
+     *
+     * Returns the matched rows by reference (already reflecting any applied mutations).
+     */
+    updateRows: (predicate: (row: T) => boolean, update: T | ((updateRow: T) => void), primaryKey?: keyof T) => T[];
+    /**
+     * Upserts rows by `primaryKey`.
+     *
+     * - If a matching key exists, the existing row is updated in place.
+     * - If no matching key exists, the row is inserted.
+     *
+     * Returns a `DataTableUpsertResult` where:
+     * - `updated` contains the incoming rows that matched existing keys.
+     * - `inserted` contains the incoming rows that were newly added.
+     */
+    upsertRows: (rows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;
+    /**
+     * Deletes matching rows and returns the deleted rows.
+     */
+    deleteRows: (predicate: (row: T) => boolean) => T[];
+    /**
+     * Sorts rows in place with the provided compare function.
+     */
+    sortRows: (compareFn: (a: T, b: T) => number) => void;
+}
+/**
+ * Generic in-memory data table with mutable row operations.
+ */
+declare class DataTable<T extends object> implements IDataTable<T>, IDataTableInitial<T> {
+    private rows;
+    constructor(initialRows?: T[]);
+    getRows: (predicate?: (row: T) => boolean) => T[];
+    setRows: (newRows: T[]) => void;
+    insertRows: (newRows: T[], primaryKey?: keyof T) => void;
+    updateRows: (predicate: (row: T) => boolean, update: T | ((updateRow: T) => void), primaryKey?: keyof T) => T[];
+    upsertRows: (newRows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;
+    deleteRows: (predicate: (row: T) => boolean) => T[];
+    sortRows: (compareFn: (a: T, b: T) => number) => void;
+}
+
+export { DataTable, type IDataTable };

package/dist/index.js

@@ -0,0 +1,74 @@
+// src/DataTable.ts
+var DataTable = class {
+  constructor(initialRows = []) {
+    this.rows = [];
+    this.getRows = (predicate) => {
+      return predicate ? this.rows.filter(predicate) : this.rows;
+    };
+    this.setRows = (newRows) => {
+      this.rows.length = 0;
+      this.rows.push(...newRows);
+    };
+    this.insertRows = (newRows, primaryKey) => {
+      if (primaryKey) {
+        if (this.rows.some((row) => newRows.findIndex((r) => r[primaryKey] === row[primaryKey]) !== -1)) {
+          throw new Error(
+            `Duplicate primary key value found in existing rows for key: ${String(primaryKey)}`
+          );
+        }
+      }
+      this.rows.push(...newRows);
+    };
+    this.updateRows = (predicate, update, primaryKey) => {
+      const updatedRows = this.rows.filter(predicate);
+      let updateFunction;
+      if (typeof update === "function") {
+        updateFunction = update;
+      } else if (primaryKey === void 0) {
+        throw new Error("Primary key must be provided when update is an object.");
+      } else {
+        updateFunction = (updateRow) => {
+          Object.assign(updateRow, { ...update, [primaryKey]: updateRow[primaryKey] });
+        };
+      }
+      for (let i = 0; i < this.rows.length; i++) {
+        if (predicate(this.rows[i])) {
+          updateFunction(this.rows[i]);
+        }
+      }
+      return updatedRows;
+    };
+    this.upsertRows = (newRows, primaryKey) => {
+      const result = { inserted: [], updated: [] };
+      const existingRowsMap = new Map(this.rows.map((row) => [row[primaryKey], row]));
+      for (const newRow of newRows) {
+        const key = newRow[primaryKey];
+        if (existingRowsMap.has(key)) {
+          Object.assign(existingRowsMap.get(key), newRow);
+          result.updated.push(newRow);
+        } else {
+          this.rows.push(newRow);
+          result.inserted.push(newRow);
+        }
+      }
+      return result;
+    };
+    this.deleteRows = (predicate) => {
+      const deletedRows = this.rows.filter(predicate);
+      for (let i = this.rows.length - 1; i >= 0; i--) {
+        if (predicate(this.rows[i])) {
+          this.rows.splice(i, 1);
+        }
+      }
+      return deletedRows;
+    };
+    this.sortRows = (compareFn) => {
+      this.rows.sort(compareFn);
+    };
+    this.rows = initialRows;
+  }
+};
+export {
+  DataTable
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/DataTable.ts"],"sourcesContent":["/**\r\n * Minimal initializer contract for replacing all rows in the table.\r\n */\r\nexport interface IDataTableInitial<T extends object> {\r\n  /**\r\n   * Replaces all current rows with the provided rows.\r\n   */\r\n  setRows: (rows: T[]) => void;\r\n}\r\n\r\n/**\r\n * Result of an upsert operation.\r\n * `inserted` contains rows that did not exist yet.\r\n * `updated` contains rows that matched an existing primary key.\r\n */\r\nexport interface DataTableUpsertResult<T extends object> {\r\n  inserted: T[];\r\n  updated: T[];\r\n}\r\n\r\n/**\r\n * Table-like CRUD and query operations for in-memory rows.\r\n */\r\nexport interface IDataTable<T extends object> {\r\n  /**\r\n   * Returns all rows, or only rows matching the predicate when provided.\r\n   */\r\n  getRows: (predicate?: (row: T) => boolean) => T[];\r\n\r\n  /**\r\n   * Appends rows to the table.\r\n   * When `primaryKey` is provided, the method validates that no incoming key\r\n   * already exists in the current table.\r\n   */\r\n  insertRows: (rows: T[], primaryKey?: keyof T) => void;\r\n\r\n  /**\r\n   * Updates all rows that match `predicate`.\r\n   *\r\n   * - When `update` is a function, the function mutates each matched row.\r\n   * - When `update` is an object, `primaryKey` is required and preserved on each row.\r\n   *\r\n   * Returns the matched rows by reference (already reflecting any applied mutations).\r\n   */\r\n  updateRows: (\r\n    predicate: (row: T) => boolean,\r\n    update: T | ((updateRow: T) => void),\r\n    primaryKey?: keyof T) => T[];\r\n\r\n  /**\r\n   * Upserts rows by `primaryKey`.\r\n   *\r\n   * - If a matching key exists, the existing row is updated in place.\r\n   * - If no matching key exists, the row is inserted.\r\n   *\r\n   * Returns a `DataTableUpsertResult` where:\r\n   * - `updated` contains the incoming rows that matched existing keys.\r\n   * - `inserted` contains the incoming rows that were newly added.\r\n   */\r\n  upsertRows: (rows: T[], primaryKey: keyof T) => DataTableUpsertResult<T>;\r\n\r\n  /**\r\n   * Deletes matching rows and returns the deleted rows.\r\n   */\r\n  deleteRows: (predicate: (row: T) => boolean) => T[];\r\n  \r\n  /**\r\n   * Sorts rows in place with the provided compare function.\r\n   */\r\n  sortRows: (compareFn: (a: T, b: T) => number) => void;\r\n}\r\n\r\n/**\r\n * Generic in-memory data table with mutable row operations.\r\n */\r\nexport class DataTable<T extends object> implements IDataTable<T>, IDataTableInitial<T> {\r\n  private rows: T[] = [];\r\n\r\n  public constructor(initialRows: T[] = []) {\r\n    this.rows = initialRows;\r\n  }\r\n\r\n  public getRows = (predicate?: (row: T) => boolean): T[] => {\r\n    return predicate ? this.rows.filter(predicate) : this.rows;\r\n  };\r\n\r\n  public setRows = (newRows: T[]): void => {\r\n    this.rows.length = 0;\r\n    this.rows.push(...newRows);\r\n  };\r\n\r\n  public insertRows = (newRows: T[], primaryKey?: keyof T): void => {\r\n    if (primaryKey) {\r\n      // Reject insert when any incoming row key already exists in the current table.\r\n      if (this.rows.some(row => newRows.findIndex(r => r[primaryKey] === row[primaryKey]) !== -1))\r\n      {\r\n        throw new Error(\r\n          `Duplicate primary key value found in existing rows for key: ${String(primaryKey)}`);\r\n      }\r\n    }\r\n    this.rows.push(...newRows);\r\n  };\r\n\r\n  public updateRows = (\r\n    predicate: (row: T) => boolean,\r\n    update: T | ((updateRow: T) => void),\r\n    primaryKey?: keyof T): T[] => {\r\n    // Keep references to matched rows; these objects are mutated in place below.\r\n    const updatedRows: T[] = this.rows.filter(predicate);\r\n\r\n    let updateFunction: (updateRow: T) => void;\r\n    if (typeof update === 'function') {\r\n      updateFunction = update as (updateRow: T) => void;\r\n    } else if (primaryKey === undefined) {\r\n      throw new Error('Primary key must be provided when update is an object.');\r\n    } else {\r\n      // Preserve the original primary key when doing object-style updates.\r\n      updateFunction = (updateRow: T): void => {\r\n        Object.assign(updateRow, { ...update, [primaryKey!]: updateRow[primaryKey!] });\r\n      };\r\n    }\r\n\r\n    for (let i = 0; i < this.rows.length; i++) {\r\n      if (predicate(this.rows[i])) {\r\n        updateFunction(this.rows[i]);\r\n      }\r\n    }\r\n\r\n    return updatedRows;\r\n  };\r\n\r\n  public upsertRows = (newRows: T[], primaryKey: keyof T): DataTableUpsertResult<T> => {\r\n    const result: DataTableUpsertResult<T> = { inserted: [], updated: [] };\r\n    // Index existing rows by primary key for efficient upsert lookup.\r\n    const existingRowsMap = new Map(this.rows.map(row => [ row[primaryKey], row ]));\r\n    for (const newRow of newRows) {\r\n      const key = newRow[primaryKey];\r\n      if (existingRowsMap.has(key)) {\r\n        Object.assign(existingRowsMap.get(key)!, newRow);\r\n        result.updated.push(newRow);\r\n      } else {\r\n        this.rows.push(newRow);\r\n        result.inserted.push(newRow);\r\n      }\r\n    }\r\n    return result;\r\n  };\r\n\r\n  public deleteRows = (predicate: (row: T) => boolean): T[] => {\r\n    const deletedRows = this.rows.filter(predicate);\r\n\r\n    // Iterate backwards to safely remove items from the same array.\r\n    for (let i = this.rows.length - 1; i >= 0; i--) {\r\n      if (predicate(this.rows[i])) {\r\n        this.rows.splice(i, 1);\r\n      }\r\n    }\r\n\r\n    return deletedRows;\r\n  };\r\n\r\n  public sortRows = (compareFn: (a: T, b: T) => number): void => {\r\n    this.rows.sort(compareFn);\r\n  };\r\n}\r\n\r\nexport default DataTable;\r\n"],"mappings":";AA2EO,IAAM,YAAN,MAAiF;AAAA,EAG/E,YAAY,cAAmB,CAAC,GAAG;AAF1C,SAAQ,OAAY,CAAC;AAMrB,SAAO,UAAU,CAAC,cAAyC;AACzD,aAAO,YAAY,KAAK,KAAK,OAAO,SAAS,IAAI,KAAK;AAAA,IACxD;AAEA,SAAO,UAAU,CAAC,YAAuB;AACvC,WAAK,KAAK,SAAS;AACnB,WAAK,KAAK,KAAK,GAAG,OAAO;AAAA,IAC3B;AAEA,SAAO,aAAa,CAAC,SAAc,eAA+B;AAChE,UAAI,YAAY;AAEd,YAAI,KAAK,KAAK,KAAK,SAAO,QAAQ,UAAU,OAAK,EAAE,UAAU,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,GAC1F;AACE,gBAAM,IAAI;AAAA,YACR,+DAA+D,OAAO,UAAU,CAAC;AAAA,UAAE;AAAA,QACvF;AAAA,MACF;AACA,WAAK,KAAK,KAAK,GAAG,OAAO;AAAA,IAC3B;AAEA,SAAO,aAAa,CAClB,WACA,QACA,eAA8B;AAE9B,YAAM,cAAmB,KAAK,KAAK,OAAO,SAAS;AAEnD,UAAI;AACJ,UAAI,OAAO,WAAW,YAAY;AAChC,yBAAiB;AAAA,MACnB,WAAW,eAAe,QAAW;AACnC,cAAM,IAAI,MAAM,wDAAwD;AAAA,MAC1E,OAAO;AAEL,yBAAiB,CAAC,cAAuB;AACvC,iBAAO,OAAO,WAAW,EAAE,GAAG,QAAQ,CAAC,UAAW,GAAG,UAAU,UAAW,EAAE,CAAC;AAAA,QAC/E;AAAA,MACF;AAEA,eAAS,IAAI,GAAG,IAAI,KAAK,KAAK,QAAQ,KAAK;AACzC,YAAI,UAAU,KAAK,KAAK,CAAC,CAAC,GAAG;AAC3B,yBAAe,KAAK,KAAK,CAAC,CAAC;AAAA,QAC7B;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,SAAO,aAAa,CAAC,SAAc,eAAkD;AACnF,YAAM,SAAmC,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC,EAAE;AAErE,YAAM,kBAAkB,IAAI,IAAI,KAAK,KAAK,IAAI,SAAO,CAAE,IAAI,UAAU,GAAG,GAAI,CAAC,CAAC;AAC9E,iBAAW,UAAU,SAAS;AAC5B,cAAM,MAAM,OAAO,UAAU;AAC7B,YAAI,gBAAgB,IAAI,GAAG,GAAG;AAC5B,iBAAO,OAAO,gBAAgB,IAAI,GAAG,GAAI,MAAM;AAC/C,iBAAO,QAAQ,KAAK,MAAM;AAAA,QAC5B,OAAO;AACL,eAAK,KAAK,KAAK,MAAM;AACrB,iBAAO,SAAS,KAAK,MAAM;AAAA,QAC7B;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,SAAO,aAAa,CAAC,cAAwC;AAC3D,YAAM,cAAc,KAAK,KAAK,OAAO,SAAS;AAG9C,eAAS,IAAI,KAAK,KAAK,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,YAAI,UAAU,KAAK,KAAK,CAAC,CAAC,GAAG;AAC3B,eAAK,KAAK,OAAO,GAAG,CAAC;AAAA,QACvB;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,SAAO,WAAW,CAAC,cAA4C;AAC7D,WAAK,KAAK,KAAK,SAAS;AAAA,IAC1B;AApFE,SAAK,OAAO;AAAA,EACd;AAoFF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capitalsix-data-table",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A lightweight, framework-agnostic in-memory data table with typed CRUD operations: insert, update, upsert, delete, sort, and query rows.",
   "license": "MIT",
   "type": "module",
@@ -26,6 +26,12 @@
   "repository": {
     "url": "https://github.com/capital-six/data-table"
   },
+  "keywords": [
+    "react",
+    "global",
+    "state",
+    "typescript"
+  ],
   "ignore": [
     "src/",
     "node_modules/",