@ricsam/formula-engine 0.0.17 → 0.0.18

package/dist/cjs/core/api/api-builder.cjs

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/api/api-builder.ts
+var exports_api_builder = {};
+__export(exports_api_builder, {
+  buildApiFromDeclaration: () => buildApiFromDeclaration
+});
+module.exports = __toCommonJS(exports_api_builder);
+var import_table_orm = require("./table-orm.cjs");
+var import_cell_orm = require("./cell-orm.cjs");
+function buildApiFromDeclaration(engine, declaration, schemaManager) {
+  const api = {};
+  for (const [namespace, def] of Object.entries(declaration)) {
+    if (def.type === "table") {
+      api[namespace] = buildTableApi(engine, namespace, def, schemaManager);
+    } else if (def.type === "cell") {
+      api[namespace] = buildCellApi(engine, namespace, def, schemaManager);
+    }
+  }
+  return api;
+}
+function buildTableApi(engine, namespace, def, schemaManager) {
+  schemaManager.registerTableSchema(namespace, def.workbookName, def.tableName, def.headers);
+  const orm = new import_table_orm.TableOrm(engine, def.workbookName, def.tableName, def.headers, namespace);
+  const boundMethods = {};
+  for (const [methodName, methodFn] of Object.entries(def.methods)) {
+    boundMethods[methodName] = methodFn.bind(orm);
+  }
+  return boundMethods;
+}
+function buildCellApi(engine, namespace, def, schemaManager) {
+  schemaManager.registerCellSchema(namespace, def.cellAddress, def.parse);
+  const orm = new import_cell_orm.CellOrm(engine, def.cellAddress, def.parse, namespace);
+  const boundMethods = {};
+  for (const [methodName, methodFn] of Object.entries(def.methods)) {
+    boundMethods[methodName] = methodFn.bind(orm);
+  }
+  return boundMethods;
+}
+
+//# debugId=1A339C89282699D664756E2164756E21

package/dist/cjs/core/api/api-builder.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/api/api-builder.ts"],
+  "sourcesContent": [
+    "/**\n * API Builder - Constructs the working API from declarations\n *\n * This module is responsible for creating the actual working API\n * from the schema declarations when attached to a FormulaEngine.\n */\n\nimport type { FormulaEngine } from \"../engine.cjs\";\nimport type { Declaration, TableApi, CellApi, Api } from \"./api.cjs\";\nimport { TableOrm } from \"./table-orm.cjs\";\nimport { CellOrm } from \"./cell-orm.cjs\";\nimport type { ApiSchemaManager } from \"../managers/api-schema-manager.cjs\";\n\n/**\n * Build the working API surface from declarations\n *\n * This creates TableOrm and CellOrm instances for each declared schema\n * and binds the custom methods to them.\n */\nexport function buildApiFromDeclaration(\n  engine: FormulaEngine<any, any>,\n  declaration: Declaration,\n  schemaManager: ApiSchemaManager\n): Api {\n  const api: Api = {};\n\n  for (const [namespace, def] of Object.entries(declaration)) {\n    if (def.type === \"table\") {\n      api[namespace] = buildTableApi(engine, namespace, def, schemaManager);\n    } else if (def.type === \"cell\") {\n      api[namespace] = buildCellApi(engine, namespace, def, schemaManager);\n    }\n  }\n\n  return api;\n}\n\n/**\n * Build API methods for a table schema\n */\nfunction buildTableApi(\n  engine: FormulaEngine<any, any>,\n  namespace: string,\n  def: TableApi,\n  schemaManager: ApiSchemaManager\n): Record<string, (...args: any[]) => any> {\n  // Register the schema with the schema manager\n  schemaManager.registerTableSchema(\n    namespace,\n    def.workbookName,\n    def.tableName,\n    def.headers\n  );\n\n  // Create the ORM instance\n  const orm = new TableOrm(\n    engine,\n    def.workbookName,\n    def.tableName,\n    def.headers,\n    namespace\n  );\n\n  // Bind all custom methods to the ORM instance\n  const boundMethods: Record<string, (...args: any[]) => any> = {};\n\n  for (const [methodName, methodFn] of Object.entries(def.methods)) {\n    boundMethods[methodName] = methodFn.bind(orm);\n  }\n\n  return boundMethods;\n}\n\n/**\n * Build API methods for a cell schema\n */\nfunction buildCellApi(\n  engine: FormulaEngine<any, any>,\n  namespace: string,\n  def: CellApi,\n  schemaManager: ApiSchemaManager\n): Record<string, (...args: any[]) => any> {\n  // Register the schema with the schema manager\n  schemaManager.registerCellSchema(namespace, def.cellAddress, def.parse);\n\n  // Create the ORM instance\n  const orm = new CellOrm(engine, def.cellAddress, def.parse, namespace);\n\n  // Bind all custom methods to the ORM instance\n  const boundMethods: Record<string, (...args: any[]) => any> = {};\n\n  for (const [methodName, methodFn] of Object.entries(def.methods)) {\n    boundMethods[methodName] = methodFn.bind(orm);\n  }\n\n  return boundMethods;\n}\n\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASyB,IAAzB;AACwB,IAAxB;AASO,SAAS,uBAAuB,CACrC,QACA,aACA,eACK;AAAA,EACL,MAAM,MAAW,CAAC;AAAA,EAElB,YAAY,WAAW,QAAQ,OAAO,QAAQ,WAAW,GAAG;AAAA,IAC1D,IAAI,IAAI,SAAS,SAAS;AAAA,MACxB,IAAI,aAAa,cAAc,QAAQ,WAAW,KAAK,aAAa;AAAA,IACtE,EAAO,SAAI,IAAI,SAAS,QAAQ;AAAA,MAC9B,IAAI,aAAa,aAAa,QAAQ,WAAW,KAAK,aAAa;AAAA,IACrE;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAMT,SAAS,aAAa,CACpB,QACA,WACA,KACA,eACyC;AAAA,EAEzC,cAAc,oBACZ,WACA,IAAI,cACJ,IAAI,WACJ,IAAI,OACN;AAAA,EAGA,MAAM,MAAM,IAAI,0BACd,QACA,IAAI,cACJ,IAAI,WACJ,IAAI,SACJ,SACF;AAAA,EAGA,MAAM,eAAwD,CAAC;AAAA,EAE/D,YAAY,YAAY,aAAa,OAAO,QAAQ,IAAI,OAAO,GAAG;AAAA,IAChE,aAAa,cAAc,SAAS,KAAK,GAAG;AAAA,EAC9C;AAAA,EAEA,OAAO;AAAA;AAMT,SAAS,YAAY,CACnB,QACA,WACA,KACA,eACyC;AAAA,EAEzC,cAAc,mBAAmB,WAAW,IAAI,aAAa,IAAI,KAAK;AAAA,EAGtE,MAAM,MAAM,IAAI,wBAAQ,QAAQ,IAAI,aAAa,IAAI,OAAO,SAAS;AAAA,EAGrE,MAAM,eAAwD,CAAC;AAAA,EAE/D,YAAY,YAAY,aAAa,OAAO,QAAQ,IAAI,OAAO,GAAG;AAAA,IAChE,aAAa,cAAc,SAAS,KAAK,GAAG;AAAA,EAC9C;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "1A339C89282699D664756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/api/api-helpers.cjs

@@ -0,0 +1,191 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/api/api-helpers.ts
+var exports_api_helpers = {};
+__export(exports_api_helpers, {
+  rowToObject: () => rowToObject,
+  objectToRowValues: () => objectToRowValues,
+  matchesFilter: () => matchesFilter,
+  iterateTableRows: () => iterateTableRows,
+  getTableRowCount: () => getTableRowCount,
+  getNextEmptyRow: () => getNextEmptyRow
+});
+module.exports = __toCommonJS(exports_api_helpers);
+function rowToObject(engine, table, rowIndex, headers, getCellMetadata) {
+  const result = {};
+  for (const [columnName, header] of Object.entries(headers)) {
+    const cellAddress = {
+      workbookName: table.workbookName,
+      sheetName: table.sheetName,
+      colIndex: table.start.colIndex + header.index,
+      rowIndex
+    };
+    const value = engine.getCellValue(cellAddress);
+    const metadata = getCellMetadata ? getCellMetadata(cellAddress) : undefined;
+    result[columnName] = header.parse(value, metadata);
+  }
+  return result;
+}
+function objectToRowValues(obj, headers) {
+  const values = new Map;
+  for (const [columnName, header] of Object.entries(headers)) {
+    if (columnName in obj) {
+      const value = obj[columnName];
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        values.set(header.index, value);
+      } else if (value === null || value === undefined) {
+        values.set(header.index, undefined);
+      } else {
+        values.set(header.index, String(value));
+      }
+    }
+  }
+  return values;
+}
+function matchesFilter(item, filter) {
+  for (const [key, value] of Object.entries(filter)) {
+    if (item[key] !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function getTableRowCount(engine, table) {
+  if (table.endRow.type === "infinity") {
+    let count = 0;
+    let emptyRowStreak = 0;
+    const maxEmptyRows = 10;
+    for (let row = table.start.rowIndex + 1;emptyRowStreak < maxEmptyRows; row++) {
+      let hasContent = false;
+      for (let col = 0;col < table.headers.size; col++) {
+        const cellAddress = {
+          workbookName: table.workbookName,
+          sheetName: table.sheetName,
+          colIndex: table.start.colIndex + col,
+          rowIndex: row
+        };
+        const value = engine.getCellValue(cellAddress);
+        if (value !== "" && value !== undefined) {
+          hasContent = true;
+          break;
+        }
+      }
+      if (hasContent) {
+        count++;
+        emptyRowStreak = 0;
+      } else {
+        emptyRowStreak++;
+      }
+    }
+    return count;
+  } else {
+    return table.endRow.value - table.start.rowIndex;
+  }
+}
+function getNextEmptyRow(engine, table) {
+  const dataStartRow = table.start.rowIndex + 1;
+  if (table.endRow.type === "infinity") {
+    let emptyRowStreak = 0;
+    const maxEmptyRows = 10;
+    for (let row = dataStartRow;; row++) {
+      let hasContent = false;
+      for (let col = 0;col < table.headers.size; col++) {
+        const cellAddress = {
+          workbookName: table.workbookName,
+          sheetName: table.sheetName,
+          colIndex: table.start.colIndex + col,
+          rowIndex: row
+        };
+        const value = engine.getCellValue(cellAddress);
+        if (value !== "" && value !== undefined) {
+          hasContent = true;
+          break;
+        }
+      }
+      if (!hasContent) {
+        return row;
+      }
+      emptyRowStreak = hasContent ? 0 : emptyRowStreak + 1;
+      if (emptyRowStreak >= maxEmptyRows) {
+        return row - maxEmptyRows + 1;
+      }
+    }
+  } else {
+    return table.endRow.value + 1;
+  }
+}
+function* iterateTableRows(engine, table) {
+  const dataStartRow = table.start.rowIndex + 1;
+  if (table.endRow.type === "infinity") {
+    let emptyRowStreak = 0;
+    const maxEmptyRows = 10;
+    for (let row = dataStartRow;emptyRowStreak < maxEmptyRows; row++) {
+      let hasContent = false;
+      for (let col = 0;col < table.headers.size; col++) {
+        const cellAddress = {
+          workbookName: table.workbookName,
+          sheetName: table.sheetName,
+          colIndex: table.start.colIndex + col,
+          rowIndex: row
+        };
+        const value = engine.getCellValue(cellAddress);
+        if (value !== "" && value !== undefined) {
+          hasContent = true;
+          break;
+        }
+      }
+      if (hasContent) {
+        emptyRowStreak = 0;
+        yield { rowIndex: row, isEmpty: false };
+      } else {
+        emptyRowStreak++;
+      }
+    }
+  } else {
+    for (let row = dataStartRow;row <= table.endRow.value; row++) {
+      let hasContent = false;
+      for (let col = 0;col < table.headers.size; col++) {
+        const cellAddress = {
+          workbookName: table.workbookName,
+          sheetName: table.sheetName,
+          colIndex: table.start.colIndex + col,
+          rowIndex: row
+        };
+        const value = engine.getCellValue(cellAddress);
+        if (value !== "" && value !== undefined) {
+          hasContent = true;
+          break;
+        }
+      }
+      yield { rowIndex: row, isEmpty: !hasContent };
+    }
+  }
+}
+
+//# debugId=3AEF0EFABA7782E064756E2164756E21

package/dist/cjs/core/api/api-helpers.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/api/api-helpers.ts"],
+  "sourcesContent": [
+    "/**\n * API Helper utilities for row/object conversion and filtering\n */\n\nimport type { CellAddress, SerializedCellValue, TableDefinition } from \"../types.cjs\";\nimport type { FormulaEngine } from \"../engine.cjs\";\n\nexport type ParseFunction<TCellMetadata = unknown> = (\n  value: unknown,\n  metadata: TCellMetadata\n) => unknown;\n\nexport type TableSchemaHeaders<TCellMetadata = unknown> = Record<\n  string,\n  {\n    parse: ParseFunction<TCellMetadata>;\n    index: number;\n  }\n>;\n\n/**\n * Convert a spreadsheet row to a typed object using header parsers\n */\nexport function rowToObject<TItem extends Record<string, unknown>>(\n  engine: FormulaEngine<any, any>,\n  table: TableDefinition,\n  rowIndex: number,\n  headers: TableSchemaHeaders,\n  getCellMetadata?: (cell: CellAddress) => unknown\n): TItem {\n  const result: Record<string, unknown> = {};\n\n  for (const [columnName, header] of Object.entries(headers)) {\n    const cellAddress: CellAddress = {\n      workbookName: table.workbookName,\n      sheetName: table.sheetName,\n      colIndex: table.start.colIndex + header.index,\n      rowIndex,\n    };\n\n    const value = engine.getCellValue(cellAddress);\n    const metadata = getCellMetadata ? getCellMetadata(cellAddress) : undefined;\n\n    // Parse the value using the column's parse function\n    result[columnName] = header.parse(value, metadata);\n  }\n\n  return result as TItem;\n}\n\n/**\n * Convert a typed object to cell values based on headers\n */\nexport function objectToRowValues<TItem extends Record<string, unknown>>(\n  obj: TItem,\n  headers: TableSchemaHeaders\n): Map<number, SerializedCellValue> {\n  const values = new Map<number, SerializedCellValue>();\n\n  for (const [columnName, header] of Object.entries(headers)) {\n    if (columnName in obj) {\n      const value = obj[columnName];\n      // Convert to serializable value\n      if (\n        typeof value === \"string\" ||\n        typeof value === \"number\" ||\n        typeof value === \"boolean\"\n      ) {\n        values.set(header.index, value);\n      } else if (value === null || value === undefined) {\n        values.set(header.index, undefined);\n      } else {\n        // For complex types, convert to string\n        values.set(header.index, String(value));\n      }\n    }\n  }\n\n  return values;\n}\n\n/**\n * Check if an object matches a filter predicate\n */\nexport function matchesFilter<TItem extends Record<string, unknown>>(\n  item: TItem,\n  filter: Partial<TItem>\n): boolean {\n  for (const [key, value] of Object.entries(filter)) {\n    if (item[key] !== value) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Get the number of data rows in a table (excluding header)\n */\nexport function getTableRowCount(\n  engine: FormulaEngine<any, any>,\n  table: TableDefinition\n): number {\n  if (table.endRow.type === \"infinity\") {\n    // For infinite tables, count non-empty rows\n    // Start from data row (after header)\n    let count = 0;\n    let emptyRowStreak = 0;\n    const maxEmptyRows = 10; // Stop after 10 consecutive empty rows\n\n    for (let row = table.start.rowIndex + 1; emptyRowStreak < maxEmptyRows; row++) {\n      let hasContent = false;\n\n      for (let col = 0; col < table.headers.size; col++) {\n        const cellAddress: CellAddress = {\n          workbookName: table.workbookName,\n          sheetName: table.sheetName,\n          colIndex: table.start.colIndex + col,\n          rowIndex: row,\n        };\n\n        const value = engine.getCellValue(cellAddress);\n        if (value !== \"\" && value !== undefined) {\n          hasContent = true;\n          break;\n        }\n      }\n\n      if (hasContent) {\n        count++;\n        emptyRowStreak = 0;\n      } else {\n        emptyRowStreak++;\n      }\n    }\n\n    return count;\n  } else {\n    // For finite tables, calculate from endRow\n    return table.endRow.value - table.start.rowIndex;\n  }\n}\n\n/**\n * Get the next empty row index for appending data\n */\nexport function getNextEmptyRow(\n  engine: FormulaEngine<any, any>,\n  table: TableDefinition\n): number {\n  const dataStartRow = table.start.rowIndex + 1;\n\n  if (table.endRow.type === \"infinity\") {\n    // Find first empty row\n    let emptyRowStreak = 0;\n    const maxEmptyRows = 10;\n\n    for (let row = dataStartRow; ; row++) {\n      let hasContent = false;\n\n      for (let col = 0; col < table.headers.size; col++) {\n        const cellAddress: CellAddress = {\n          workbookName: table.workbookName,\n          sheetName: table.sheetName,\n          colIndex: table.start.colIndex + col,\n          rowIndex: row,\n        };\n\n        const value = engine.getCellValue(cellAddress);\n        if (value !== \"\" && value !== undefined) {\n          hasContent = true;\n          break;\n        }\n      }\n\n      if (!hasContent) {\n        return row;\n      }\n\n      emptyRowStreak = hasContent ? 0 : emptyRowStreak + 1;\n      if (emptyRowStreak >= maxEmptyRows) {\n        return row - maxEmptyRows + 1;\n      }\n    }\n  } else {\n    // For finite tables, return the row after the last data row\n    return table.endRow.value + 1;\n  }\n}\n\n/**\n * Iterate over all data rows in a table\n */\nexport function* iterateTableRows(\n  engine: FormulaEngine<any, any>,\n  table: TableDefinition\n): Generator<{ rowIndex: number; isEmpty: boolean }> {\n  const dataStartRow = table.start.rowIndex + 1;\n\n  if (table.endRow.type === \"infinity\") {\n    let emptyRowStreak = 0;\n    const maxEmptyRows = 10;\n\n    for (let row = dataStartRow; emptyRowStreak < maxEmptyRows; row++) {\n      let hasContent = false;\n\n      for (let col = 0; col < table.headers.size; col++) {\n        const cellAddress: CellAddress = {\n          workbookName: table.workbookName,\n          sheetName: table.sheetName,\n          colIndex: table.start.colIndex + col,\n          rowIndex: row,\n        };\n\n        const value = engine.getCellValue(cellAddress);\n        if (value !== \"\" && value !== undefined) {\n          hasContent = true;\n          break;\n        }\n      }\n\n      if (hasContent) {\n        emptyRowStreak = 0;\n        yield { rowIndex: row, isEmpty: false };\n      } else {\n        emptyRowStreak++;\n        // Don't yield empty rows at the end\n      }\n    }\n  } else {\n    for (let row = dataStartRow; row <= table.endRow.value; row++) {\n      let hasContent = false;\n\n      for (let col = 0; col < table.headers.size; col++) {\n        const cellAddress: CellAddress = {\n          workbookName: table.workbookName,\n          sheetName: table.sheetName,\n          colIndex: table.start.colIndex + col,\n          rowIndex: row,\n        };\n\n        const value = engine.getCellValue(cellAddress);\n        if (value !== \"\" && value !== undefined) {\n          hasContent = true;\n          break;\n        }\n      }\n\n      yield { rowIndex: row, isEmpty: !hasContent };\n    }\n  }\n}\n\n"
+  ],
+  "mappings": "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",
+  "debugId": "3AEF0EFABA7782E064756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/api/api.cjs

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/api/api.ts
+var exports_api = {};
+__export(exports_api, {
+  defineApi: () => defineApi,
+  createApi: () => createApi
+});
+module.exports = __toCommonJS(exports_api);
+function defineApi() {
+  const declaration = {};
+  const builder = {
+    addTableApi(namespace, address, headers, methods) {
+      declaration[namespace] = {
+        type: "table",
+        tableName: address.tableName,
+        workbookName: address.workbookName,
+        headers,
+        methods
+      };
+      return builder;
+    },
+    addCellApi(namespace, cellAddress, parse, methods) {
+      declaration[namespace] = {
+        type: "cell",
+        cellAddress,
+        parse,
+        methods
+      };
+      return builder;
+    },
+    api: undefined,
+    declaration
+  };
+  return builder;
+}
+var createApi = defineApi;
+
+//# debugId=00202A4557ACD94664756E2164756E21

package/dist/cjs/core/api/api.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/api/api.ts"],
+  "sourcesContent": [
+    "import type { CellAddress } from \"../types.cjs\";\nimport type { CellOrm } from \"./cell-orm.cjs\";\nimport type { TableOrm } from \"./table-orm.cjs\";\n\n/**\n * Define an API schema for the FormulaEngine.\n *\n * The returned object contains:\n * - `declaration`: The schema definitions for tables and cells\n * - `api`: A type-only placeholder (undefined at runtime) for TypeScript inference\n *\n * The actual working API is only available through `engine.api` after\n * attaching the definition to a FormulaEngine instance.\n *\n * @example\n * ```typescript\n * const myApi = defineApi<CellMetadata>()\n *   .addTableApi(\"users\", { workbookName: \"wb1\", tableName: \"users\" }, headers, methods)\n *   .addCellApi(\"config\", cellAddress, parse, methods);\n *\n * const engine = new FormulaEngine(myApi);\n * engine.api.users.get(1); // Works!\n * myApi.api.users.get(1);  // Error: api is undefined at runtime\n * ```\n */\nexport function defineApi<\n  TCellMetadata = unknown,\n  TCurrentApi extends Record<\n    string,\n    Record<string, (...args: any[]) => any>\n  > = Record<string, Record<string, (...args: any[]) => any>>,\n  TCurrentDeclaration extends Record<string, TableApi | CellApi> = Record<\n    string,\n    TableApi | CellApi\n  >\n>(): CreateApi<TCellMetadata, TCurrentApi, TCurrentDeclaration> {\n  const declaration: Record<string, TableApi | CellApi> = {};\n\n  const builder: CreateApi<TCellMetadata, TCurrentApi, TCurrentDeclaration> = {\n    addTableApi(namespace, address, headers, methods) {\n      declaration[namespace] = {\n        type: \"table\",\n        tableName: address.tableName,\n        workbookName: address.workbookName,\n        headers: headers as any,\n        methods: methods as any,\n      };\n      return builder as any;\n    },\n\n    addCellApi(namespace, cellAddress, parse, methods) {\n      declaration[namespace] = {\n        type: \"cell\",\n        cellAddress,\n        parse: parse as any,\n        methods: methods as any,\n      };\n      return builder as any;\n    },\n\n    // api is undefined at runtime - it only exists for TypeScript type inference\n    // The actual working API is built by the FormulaEngine constructor\n    api: undefined as any as TCurrentApi,\n\n    declaration: declaration as TCurrentDeclaration,\n  };\n\n  return builder;\n}\n\n// Keep createApi as an alias for backwards compatibility\nexport const createApi = defineApi;\n\ntype ParseFunction<TCellMetadata> = (\n  value: unknown,\n  metadata: TCellMetadata\n) => unknown;\n\nexport interface TableApi {\n  type: \"table\";\n  headers: Headers<unknown>;\n  tableName: string;\n  workbookName: string;\n  methods: TableMethods<Record<string, unknown>>;\n}\n\nexport interface CellApi {\n  type: \"cell\";\n  cellAddress: CellAddress;\n  parse: (value: unknown, metadata: unknown) => unknown;\n  methods: CellMethods<unknown>;\n}\n\ntype Headers<TCellMetadata> = Record<\n  string,\n  {\n    parse: ParseFunction<TCellMetadata>;\n    index: number;\n  }\n>;\n\ntype TableMethods<TItem extends Record<string, unknown>> = Record<\n  string,\n  (this: TableOrm<TItem>, ...args: any[]) => any\n>;\n\ntype CellMethods<TValue> = Record<\n  string,\n  (this: CellOrm<TValue>, ...args: any[]) => any\n>;\n\nexport type Declaration = Record<string, TableApi | CellApi>;\nexport type Api = Record<string, Record<string, (...args: any[]) => any>>;\n\nexport type CreateApi<\n  TCellMetadata,\n  TCurrentApi extends Api,\n  TCurrentDeclaration extends Declaration\n> = {\n  addTableApi<\n    T extends string,\n    THeaders extends Headers<TCellMetadata>,\n    TMethods extends TableMethods<{\n      [K in keyof THeaders]: ReturnType<THeaders[K][\"parse\"]>;\n    }>\n  >(\n    namespace: T,\n    address: { workbookName: string; tableName: string },\n    headers: THeaders,\n    methods: TMethods\n  ): CreateApi<\n    TCellMetadata,\n    TCurrentApi & {\n      [K in T]: {\n        [M in keyof TMethods]: (\n          ...args: Parameters<TMethods[M]>\n        ) => ReturnType<TMethods[M]>;\n      };\n    },\n    TCurrentDeclaration & {\n      [K in T]: {\n        type: \"table\";\n        tableName: string;\n        workbookName: string;\n        headers: THeaders;\n        methods: TMethods;\n      };\n    }\n  >;\n  addCellApi<T extends string, TValue, TMethods extends CellMethods<TValue>>(\n    namespace: T,\n    cellAddress: CellAddress,\n    parse: (value: unknown, metadata: TCellMetadata) => TValue,\n    methods: TMethods\n  ): CreateApi<\n    TCellMetadata,\n    TCurrentApi & {\n      [K in T]: {\n        [M in keyof TMethods]: (\n          ...args: Parameters<TMethods[M]>\n        ) => ReturnType<TMethods[M]>;\n      };\n    },\n    TCurrentDeclaration & {\n      [K in T]: {\n        type: \"cell\";\n        cellAddress: CellAddress;\n        parse: (value: unknown, metadata: unknown) => unknown;\n        methods: TMethods;\n      };\n    }\n  >;\n  api: TCurrentApi;\n  declaration: TCurrentDeclaration;\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBO,SAAS,SAUf,GAA+D;AAAA,EAC9D,MAAM,cAAkD,CAAC;AAAA,EAEzD,MAAM,UAAsE;AAAA,IAC1E,WAAW,CAAC,WAAW,SAAS,SAAS,SAAS;AAAA,MAChD,YAAY,aAAa;AAAA,QACvB,MAAM;AAAA,QACN,WAAW,QAAQ;AAAA,QACnB,cAAc,QAAQ;AAAA,QACtB;AAAA,QACA;AAAA,MACF;AAAA,MACA,OAAO;AAAA;AAAA,IAGT,UAAU,CAAC,WAAW,aAAa,OAAO,SAAS;AAAA,MACjD,YAAY,aAAa;AAAA,QACvB,MAAM;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,MACA,OAAO;AAAA;AAAA,IAKT,KAAK;AAAA,IAEL;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAIF,IAAM,YAAY;",
+  "debugId": "00202A4557ACD94664756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/api/cell-orm.cjs

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/api/cell-orm.ts
+var exports_cell_orm = {};
+__export(exports_cell_orm, {
+  CellOrm: () => CellOrm
+});
+module.exports = __toCommonJS(exports_cell_orm);
+
+class CellOrm {
+  engine;
+  cellAddress;
+  parser;
+  namespace;
+  constructor(engine, cellAddress, parser, namespace) {
+    this.engine = engine;
+    this.cellAddress = cellAddress;
+    this.parser = parser;
+    this.namespace = namespace;
+  }
+  read() {
+    const value = this.engine.getCellValue(this.cellAddress);
+    const metadata = this.engine.getCellMetadata(this.cellAddress);
+    return this.parser(value, metadata);
+  }
+  write(value) {
+    let serializedValue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      serializedValue = value;
+    } else if (value === null || value === undefined) {
+      serializedValue = undefined;
+    } else if (typeof value === "object") {
+      const obj = value;
+      if ("value" in obj) {
+        const innerValue = obj.value;
+        if (typeof innerValue === "string" || typeof innerValue === "number" || typeof innerValue === "boolean") {
+          serializedValue = innerValue;
+        } else {
+          serializedValue = String(innerValue);
+        }
+      } else {
+        serializedValue = JSON.stringify(value);
+      }
+    } else {
+      serializedValue = String(value);
+    }
+    this.engine.setCellContent(this.cellAddress, serializedValue);
+  }
+  getAddress() {
+    return { ...this.cellAddress };
+  }
+}
+
+//# debugId=65719C8FCB16AB7864756E2164756E21

package/dist/cjs/core/api/cell-orm.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/api/cell-orm.ts"],
+  "sourcesContent": [
+    "/**\n * CellOrm - Object-Relational Mapping for single cell data\n *\n * Provides read/write operations for a single cell with type-safe access.\n * Used as the `this` context for custom cell API methods.\n */\n\nimport type { CellAddress, SerializedCellValue } from \"../types.cjs\";\nimport type { FormulaEngine } from \"../engine.cjs\";\n\nexport type CellParseFunction<TCellMetadata, TValue> = (\n  value: unknown,\n  metadata: TCellMetadata\n) => TValue;\n\nexport class CellOrm<TValue, TCellMetadata = unknown> {\n  constructor(\n    private engine: FormulaEngine<any, any>,\n    private cellAddress: CellAddress,\n    private parser: CellParseFunction<TCellMetadata, TValue>,\n    private namespace: string\n  ) {}\n\n  /**\n   * Read the cell value and parse it using the schema's parse function\n   */\n  read(): TValue {\n    const value = this.engine.getCellValue(this.cellAddress);\n    const metadata = this.engine.getCellMetadata(this.cellAddress) as TCellMetadata;\n    return this.parser(value, metadata);\n  }\n\n  /**\n   * Write a value to the cell\n   * The value should be the parsed type - it will be converted to a serializable value\n   */\n  write(value: TValue): void {\n    // Convert TValue to SerializedCellValue\n    let serializedValue: SerializedCellValue;\n\n    if (\n      typeof value === \"string\" ||\n      typeof value === \"number\" ||\n      typeof value === \"boolean\"\n    ) {\n      serializedValue = value;\n    } else if (value === null || value === undefined) {\n      serializedValue = undefined;\n    } else if (typeof value === \"object\") {\n      // For objects, we need to extract the actual cell value\n      // This assumes the parsed type might be an object with a 'value' property\n      const obj = value as Record<string, unknown>;\n      if (\"value\" in obj) {\n        const innerValue = obj.value;\n        if (\n          typeof innerValue === \"string\" ||\n          typeof innerValue === \"number\" ||\n          typeof innerValue === \"boolean\"\n        ) {\n          serializedValue = innerValue;\n        } else {\n          serializedValue = String(innerValue);\n        }\n      } else {\n        // Fallback: convert to string\n        serializedValue = JSON.stringify(value);\n      }\n    } else {\n      serializedValue = String(value);\n    }\n\n    this.engine.setCellContent(this.cellAddress, serializedValue);\n  }\n\n  /**\n   * Get the cell address\n   */\n  getAddress(): CellAddress {\n    return { ...this.cellAddress };\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,MAAM,QAAyC;AAAA,EAE1C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAJV,WAAW,CACD,QACA,aACA,QACA,WACR;AAAA,IAJQ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,EAMV,IAAI,GAAW;AAAA,IACb,MAAM,QAAQ,KAAK,OAAO,aAAa,KAAK,WAAW;AAAA,IACvD,MAAM,WAAW,KAAK,OAAO,gBAAgB,KAAK,WAAW;AAAA,IAC7D,OAAO,KAAK,OAAO,OAAO,QAAQ;AAAA;AAAA,EAOpC,KAAK,CAAC,OAAqB;AAAA,IAEzB,IAAI;AAAA,IAEJ,IACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,WACjB;AAAA,MACA,kBAAkB;AAAA,IACpB,EAAO,SAAI,UAAU,QAAQ,UAAU,WAAW;AAAA,MAChD,kBAAkB;AAAA,IACpB,EAAO,SAAI,OAAO,UAAU,UAAU;AAAA,MAGpC,MAAM,MAAM;AAAA,MACZ,IAAI,WAAW,KAAK;AAAA,QAClB,MAAM,aAAa,IAAI;AAAA,QACvB,IACE,OAAO,eAAe,YACtB,OAAO,eAAe,YACtB,OAAO,eAAe,WACtB;AAAA,UACA,kBAAkB;AAAA,QACpB,EAAO;AAAA,UACL,kBAAkB,OAAO,UAAU;AAAA;AAAA,MAEvC,EAAO;AAAA,QAEL,kBAAkB,KAAK,UAAU,KAAK;AAAA;AAAA,IAE1C,EAAO;AAAA,MACL,kBAAkB,OAAO,KAAK;AAAA;AAAA,IAGhC,KAAK,OAAO,eAAe,KAAK,aAAa,eAAe;AAAA;AAAA,EAM9D,UAAU,GAAgB;AAAA,IACxB,OAAO,KAAK,KAAK,YAAY;AAAA;AAEjC;",
+  "debugId": "65719C8FCB16AB7864756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/api/table-orm.cjs

@@ -0,0 +1,171 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/api/table-orm.ts
+var exports_table_orm = {};
+__export(exports_table_orm, {
+  TableOrm: () => TableOrm
+});
+module.exports = __toCommonJS(exports_table_orm);
+var import_api_helpers = require("./api-helpers.cjs");
+
+class TableOrm {
+  engine;
+  workbookName;
+  tableName;
+  headers;
+  namespace;
+  constructor(engine, workbookName, tableName, headers, namespace) {
+    this.engine = engine;
+    this.workbookName = workbookName;
+    this.tableName = tableName;
+    this.headers = headers;
+    this.namespace = namespace;
+  }
+  getTable() {
+    const table = this.engine._tableManager.getTable({
+      workbookName: this.workbookName,
+      name: this.tableName
+    });
+    if (!table) {
+      throw new Error(`Table "${this.tableName}" not found in workbook "${this.workbookName}"`);
+    }
+    return table;
+  }
+  findWhere(filter) {
+    const table = this.getTable();
+    for (const { rowIndex, isEmpty } of import_api_helpers.iterateTableRows(this.engine, table)) {
+      if (isEmpty)
+        continue;
+      try {
+        const item = import_api_helpers.rowToObject(this.engine, table, rowIndex, this.headers, (cell) => this.engine.getCellMetadata(cell));
+        if (import_api_helpers.matchesFilter(item, filter)) {
+          return item;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return;
+  }
+  findAllWhere(filter) {
+    const table = this.getTable();
+    const results = [];
+    for (const { rowIndex, isEmpty } of import_api_helpers.iterateTableRows(this.engine, table)) {
+      if (isEmpty)
+        continue;
+      try {
+        const item = import_api_helpers.rowToObject(this.engine, table, rowIndex, this.headers, (cell) => this.engine.getCellMetadata(cell));
+        if (import_api_helpers.matchesFilter(item, filter)) {
+          results.push(item);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  }
+  append(item) {
+    const table = this.getTable();
+    const nextRow = import_api_helpers.getNextEmptyRow(this.engine, table);
+    const values = import_api_helpers.objectToRowValues(item, this.headers);
+    for (const [colOffset, value] of values) {
+      const cellAddress = {
+        workbookName: table.workbookName,
+        sheetName: table.sheetName,
+        colIndex: table.start.colIndex + colOffset,
+        rowIndex: nextRow
+      };
+      this.engine.setCellContent(cellAddress, value);
+    }
+    return item;
+  }
+  updateWhere(filter, update) {
+    const table = this.getTable();
+    let updatedCount = 0;
+    for (const { rowIndex, isEmpty } of import_api_helpers.iterateTableRows(this.engine, table)) {
+      if (isEmpty)
+        continue;
+      try {
+        const item = import_api_helpers.rowToObject(this.engine, table, rowIndex, this.headers, (cell) => this.engine.getCellMetadata(cell));
+        if (import_api_helpers.matchesFilter(item, filter)) {
+          const values = import_api_helpers.objectToRowValues(update, this.headers);
+          for (const [colOffset, value] of values) {
+            const cellAddress = {
+              workbookName: table.workbookName,
+              sheetName: table.sheetName,
+              colIndex: table.start.colIndex + colOffset,
+              rowIndex
+            };
+            this.engine.setCellContent(cellAddress, value);
+          }
+          updatedCount++;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return updatedCount;
+  }
+  removeWhere(filter) {
+    const table = this.getTable();
+    let removedCount = 0;
+    const rowsToRemove = [];
+    for (const { rowIndex, isEmpty } of import_api_helpers.iterateTableRows(this.engine, table)) {
+      if (isEmpty)
+        continue;
+      try {
+        const item = import_api_helpers.rowToObject(this.engine, table, rowIndex, this.headers, (cell) => this.engine.getCellMetadata(cell));
+        if (import_api_helpers.matchesFilter(item, filter)) {
+          rowsToRemove.push(rowIndex);
+        }
+      } catch {
+        continue;
+      }
+    }
+    for (const rowIndex of rowsToRemove.reverse()) {
+      for (const header of Object.values(this.headers)) {
+        const cellAddress = {
+          workbookName: table.workbookName,
+          sheetName: table.sheetName,
+          colIndex: table.start.colIndex + header.index,
+          rowIndex
+        };
+        this.engine.setCellContent(cellAddress, undefined);
+      }
+      removedCount++;
+    }
+    return removedCount;
+  }
+  count() {
+    const table = this.getTable();
+    return import_api_helpers.getTableRowCount(this.engine, table);
+  }
+}
+
+//# debugId=EAD2C30DE3B432C664756E2164756E21