@kaspernj/api-maker 1.0.2171 → 1.0.2172

package/build/config.d.ts

@@ -62,5 +62,26 @@ declare class ApiMakerConfig {
      * @param {boolean} _newValue
      */
     setUseHtmlForm(_newValue: boolean): void;
+    /**
+     * Opens a streaming file sink for table exports on platforms without a web default (e.g. React
+     * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink
+     * `{write(chunk), close(), abort()}`.
+     * @returns {((args: object) => Promise<object>) | undefined}
+     */
+    getExportFileSinkOpener(): ((args: object) => Promise<object>) | undefined;
+    /**
+     * @param {((args: object) => Promise<object>) | undefined} opener
+     */
+    setExportFileSinkOpener(opener: ((args: object) => Promise<object>) | undefined): void;
+    /**
+     * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format
+     * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).
+     * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}
+     */
+    getExportXlsxSerializer(): ((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined;
+    /**
+     * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer
+     */
+    setExportXlsxSerializer(serializer: ((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined): void;
 }
 //# sourceMappingURL=config.d.ts.map

package/build/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":";mCAIc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC;6BAChC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;uBAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;+BACtB;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAC;2BAE9C;IAAC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;CAAC;0BAG5F,oBAAoB,EAAE,GAAG,cAAc,EAAE,GAAG,QAAQ,GAAG,gBAAgB,GAAG,YAAY,GAClG,OAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;AAyJnD,6CAA2C;6BArKhB,eAAe;AAkD1C,uFAAuF;AACvF;IAKI,YAA6C;IAC7C,2CAAgC;IAGlC;;;OAGG;IACH,aAFa,YAAY,CAES;IAElC,kDAAkD;IAClD,cADc,OAAO,SAAS,EAAE,cAAc,CAG7C;IAED,wBAAwB;IACxB,WADc,MAAM,CAGnB;IAED,oCAAoC;IACpC,eADc,MAAM,GAAG,SAAS,CAG/B;IAED,wBAAwB;IACxB,iCADc,MAAM,CAGnB;IAED;;OAEG;IACH,yCAFW,MAAM,QAEyF;IAE1G;;OAEG;IACH,uBAFW,MAAM,GAAG,SAAS,QAEyC;IAEtE,qCAAqC;IACrC,wBADc,OAAO,GAAG,SAAS,CAGhC;IAED;;OAEG;IACH,gCAFW,OAAO,GAAG,SAAS,QAE0D;IAExF,uCAAuC;IACvC,2BADc,KAAK,CAAC,cAAc,CAAC,CAGlC;IAED,wBAAwB;IACxB,YADc,MAAM,CAGnB;IAED,kCAAkC;IAClC,uBADc,gBAAgB,CAG7B;IAED,0BAA0B;IAC1B,aADc,QAAQ,CAGrB;IAED,yBAAyB;IACzB,kBADc,OAAO,CAGpB;IAED;;OAEG;IACH,0BAFW,OAAO,QAE0D;CAC7E"}
+{"version":3,"file":"config.d.ts","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":";mCAIc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC;6BAChC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;uBAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;+BACtB;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAC;2BAE9C;IAAC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;CAAC;0BAG5F,oBAAoB,EAAE,GAAG,cAAc,EAAE,GAAG,QAAQ,GAAG,gBAAgB,GAAG,YAAY,GAClG,OAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;AAqLnD,6CAA2C;6BAjMhB,eAAe;AAkD1C,uFAAuF;AACvF;IAKI,YAA6C;IAC7C,2CAAgC;IAGlC;;;OAGG;IACH,aAFa,YAAY,CAES;IAElC,kDAAkD;IAClD,cADc,OAAO,SAAS,EAAE,cAAc,CAG7C;IAED,wBAAwB;IACxB,WADc,MAAM,CAGnB;IAED,oCAAoC;IACpC,eADc,MAAM,GAAG,SAAS,CAG/B;IAED,wBAAwB;IACxB,iCADc,MAAM,CAGnB;IAED;;OAEG;IACH,yCAFW,MAAM,QAEyF;IAE1G;;OAEG;IACH,uBAFW,MAAM,GAAG,SAAS,QAEyC;IAEtE,qCAAqC;IACrC,wBADc,OAAO,GAAG,SAAS,CAGhC;IAED;;OAEG;IACH,gCAFW,OAAO,GAAG,SAAS,QAE0D;IAExF,uCAAuC;IACvC,2BADc,KAAK,CAAC,cAAc,CAAC,CAGlC;IAED,wBAAwB;IACxB,YADc,MAAM,CAGnB;IAED,kCAAkC;IAClC,uBADc,gBAAgB,CAG7B;IAED,0BAA0B;IAC1B,aADc,QAAQ,CAGrB;IAED,yBAAyB;IACzB,kBADc,OAAO,CAGpB;IAED;;OAEG;IACH,0BAFW,OAAO,QAE0D;IAK5E;;;;;OAKG;IACH,2BAFa,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAES;IAErE;;OAEG;IACH,gCAFW,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,QAEmB;IAE7E;;;;OAIG;IACH,2BAFa,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAEvB;IAErE;;OAEG;IACH,oCAFW,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,QAEL;CACtF"}

package/build/config.js

@@ -115,6 +115,29 @@ class ApiMakerConfig {
      * @param {boolean} _newValue
      */
     setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented("setUseHtmlForm"); }
+    // Table export hooks. These hold functions that should be returned as-is (not invoked), so they use
+    // explicit accessors instead of the generic accessor loop below (which would call function values).
+    /**
+     * Opens a streaming file sink for table exports on platforms without a web default (e.g. React
+     * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink
+     * `{write(chunk), close(), abort()}`.
+     * @returns {((args: object) => Promise<object>) | undefined}
+     */
+    getExportFileSinkOpener() { return this.global.exportFileSinkOpener; }
+    /**
+     * @param {((args: object) => Promise<object>) | undefined} opener
+     */
+    setExportFileSinkOpener(opener) { this.global.exportFileSinkOpener = opener; }
+    /**
+     * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format
+     * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).
+     * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}
+     */
+    getExportXlsxSerializer() { return this.global.exportXlsxSerializer; }
+    /**
+     * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer
+     */
+    setExportXlsxSerializer(serializer) { this.global.exportXlsxSerializer = serializer; }
 }
 for (const accessorName in accessors) {
     const accessorData = accessors[accessorName];
@@ -141,4 +164,4 @@ for (const accessorName in accessors) {
 }
 const apiMakerConfig = new ApiMakerConfig();
 export default apiMakerConfig;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {EventEmitter} from \"eventemitter3\"\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\n\n/** @typedef {[name: string, minWidth: number]} BreakpointDefinition */\n/** @typedef {[label: string, code: string]} CurrencyOption */\n/** @typedef {Record<string, object>} RouteMap */\n/** @typedef {{routes: Array<{name: string, path: string}>}} RouteDefinitions */\n/**\n * @typedef {{emit: (eventName: string, payload: {oldValue: ConfigValue, newValue: ConfigValue}) => void}} ConfigEvents\n */\n/**\n * @typedef {BreakpointDefinition[] | CurrencyOption[] | RouteMap | RouteDefinitions | EventEmitter |\n *   boolean | number | object | string | undefined} ConfigValue\n */\n\nconst accessors = {\n  breakpoints: {\n    default: [\n      [\"xxl\", 1400],\n      [\"xl\", 1200],\n      [\"lg\", 992],\n      [\"md\", 768],\n      [\"sm\", 576],\n      [\"xs\", 0]\n    ],\n    required: true\n  },\n  cableUrl: {require: false},\n  currenciesCollection: {required: true},\n  dangerousRowCountThreshold: {default: 1000, required: false},\n  history: {required: true},\n  host: {required: false},\n  i18n: {required: false},\n  linkTo: {required: true},\n  modal: {required: false},\n  navigation: {required: true},\n  routes: {required: false},\n  routeDefinitions: {required: false},\n  useHtmlForm: {default: false, required: false},\n  websocketRequests: {required: false}\n}\n\n/**\n * @param {string} methodName\n * @returns {never}\n */\nconst apiMakerConfigNotImplemented = (methodName) => {\n  throw new Error(`'${methodName}' not implemented`)\n}\n\n/** Stores globally configured Api Maker integration hooks and runtime dependencies. */\nclass ApiMakerConfig {\n  /** Initializes the shared config state and change emitter. */\n  constructor() {\n    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {}\n\n    this.global = globalThis.apiMakerConfigGlobal\n    this.events = new EventEmitter()\n  }\n\n  /**\n   * Returns the event emitter used for config change notifications.\n   * @returns {ConfigEvents}\n   */\n  getEvents() { return this.events }\n\n  /** @returns {import(\"history\").BrowserHistory} */\n  getHistory() {\n    return apiMakerConfigNotImplemented(\"getHistory\")\n  }\n\n  /** @returns {string} */\n  getHost() {\n    return apiMakerConfigNotImplemented(\"getHost\")\n  }\n\n  /** @returns {string | undefined} */\n  getCableUrl() {\n    return apiMakerConfigNotImplemented(\"getCableUrl\")\n  }\n\n  /** @returns {number} */\n  getDangerousRowCountThreshold() {\n    return apiMakerConfigNotImplemented(\"getDangerousRowCountThreshold\")\n  }\n\n  /**\n   * @param {number} _newValue\n   */\n  setDangerousRowCountThreshold(_newValue) { apiMakerConfigNotImplemented(\"setDangerousRowCountThreshold\") }\n\n  /**\n   * @param {string | undefined} _newValue\n   */\n  setCableUrl(_newValue) { apiMakerConfigNotImplemented(\"setCableUrl\") }\n\n  /** @returns {boolean | undefined} */\n  getWebsocketRequests() {\n    return apiMakerConfigNotImplemented(\"getWebsocketRequests\")\n  }\n\n  /**\n   * @param {boolean | undefined} _newValue\n   */\n  setWebsocketRequests(_newValue) { apiMakerConfigNotImplemented(\"setWebsocketRequests\") }\n\n  /** @returns {Array<CurrencyOption>} */\n  getCurrenciesCollection() {\n    return apiMakerConfigNotImplemented(\"getCurrenciesCollection\")\n  }\n\n  /** @returns {object} */\n  getModal() {\n    return apiMakerConfigNotImplemented(\"getModal\")\n  }\n\n  /** @returns {RouteDefinitions} */\n  getRouteDefinitions() {\n    return apiMakerConfigNotImplemented(\"getRouteDefinitions\")\n  }\n\n  /** @returns {RouteMap} */\n  getRoutes() {\n    return apiMakerConfigNotImplemented(\"getRoutes\")\n  }\n\n  /** @returns {boolean} */\n  getUseHtmlForm() {\n    return apiMakerConfigNotImplemented(\"getUseHtmlForm\")\n  }\n\n  /**\n   * @param {boolean} _newValue\n   */\n  setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented(\"setUseHtmlForm\") }\n}\n\nfor (const accessorName in accessors) {\n  const accessorData = accessors[accessorName]\n  const camelizedAccessor = inflection.camelize(accessorName)\n\n  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {\n    const oldValue = this.global[accessorName]\n\n    this.global[accessorName] = newValue\n\n    if (oldValue !== newValue) {\n      this.events.emit(`on${camelizedAccessor}Change`, {oldValue, newValue})\n    }\n  }\n\n  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {\n    if (this.global[accessorName] === undefined) {\n      if (accessorData.default !== undefined) return accessorData.default\n      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`)\n    }\n\n    const value = this.global[accessorName]\n\n    if (typeof value == \"function\") return value(...args)\n\n    return value\n  }\n}\n\nconst apiMakerConfig = new ApiMakerConfig()\n\nexport default apiMakerConfig\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {EventEmitter} from \"eventemitter3\"\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\n\n/** @typedef {[name: string, minWidth: number]} BreakpointDefinition */\n/** @typedef {[label: string, code: string]} CurrencyOption */\n/** @typedef {Record<string, object>} RouteMap */\n/** @typedef {{routes: Array<{name: string, path: string}>}} RouteDefinitions */\n/**\n * @typedef {{emit: (eventName: string, payload: {oldValue: ConfigValue, newValue: ConfigValue}) => void}} ConfigEvents\n */\n/**\n * @typedef {BreakpointDefinition[] | CurrencyOption[] | RouteMap | RouteDefinitions | EventEmitter |\n *   boolean | number | object | string | undefined} ConfigValue\n */\n\nconst accessors = {\n  breakpoints: {\n    default: [\n      [\"xxl\", 1400],\n      [\"xl\", 1200],\n      [\"lg\", 992],\n      [\"md\", 768],\n      [\"sm\", 576],\n      [\"xs\", 0]\n    ],\n    required: true\n  },\n  cableUrl: {require: false},\n  currenciesCollection: {required: true},\n  dangerousRowCountThreshold: {default: 1000, required: false},\n  history: {required: true},\n  host: {required: false},\n  i18n: {required: false},\n  linkTo: {required: true},\n  modal: {required: false},\n  navigation: {required: true},\n  routes: {required: false},\n  routeDefinitions: {required: false},\n  useHtmlForm: {default: false, required: false},\n  websocketRequests: {required: false}\n}\n\n/**\n * @param {string} methodName\n * @returns {never}\n */\nconst apiMakerConfigNotImplemented = (methodName) => {\n  throw new Error(`'${methodName}' not implemented`)\n}\n\n/** Stores globally configured Api Maker integration hooks and runtime dependencies. */\nclass ApiMakerConfig {\n  /** Initializes the shared config state and change emitter. */\n  constructor() {\n    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {}\n\n    this.global = globalThis.apiMakerConfigGlobal\n    this.events = new EventEmitter()\n  }\n\n  /**\n   * Returns the event emitter used for config change notifications.\n   * @returns {ConfigEvents}\n   */\n  getEvents() { return this.events }\n\n  /** @returns {import(\"history\").BrowserHistory} */\n  getHistory() {\n    return apiMakerConfigNotImplemented(\"getHistory\")\n  }\n\n  /** @returns {string} */\n  getHost() {\n    return apiMakerConfigNotImplemented(\"getHost\")\n  }\n\n  /** @returns {string | undefined} */\n  getCableUrl() {\n    return apiMakerConfigNotImplemented(\"getCableUrl\")\n  }\n\n  /** @returns {number} */\n  getDangerousRowCountThreshold() {\n    return apiMakerConfigNotImplemented(\"getDangerousRowCountThreshold\")\n  }\n\n  /**\n   * @param {number} _newValue\n   */\n  setDangerousRowCountThreshold(_newValue) { apiMakerConfigNotImplemented(\"setDangerousRowCountThreshold\") }\n\n  /**\n   * @param {string | undefined} _newValue\n   */\n  setCableUrl(_newValue) { apiMakerConfigNotImplemented(\"setCableUrl\") }\n\n  /** @returns {boolean | undefined} */\n  getWebsocketRequests() {\n    return apiMakerConfigNotImplemented(\"getWebsocketRequests\")\n  }\n\n  /**\n   * @param {boolean | undefined} _newValue\n   */\n  setWebsocketRequests(_newValue) { apiMakerConfigNotImplemented(\"setWebsocketRequests\") }\n\n  /** @returns {Array<CurrencyOption>} */\n  getCurrenciesCollection() {\n    return apiMakerConfigNotImplemented(\"getCurrenciesCollection\")\n  }\n\n  /** @returns {object} */\n  getModal() {\n    return apiMakerConfigNotImplemented(\"getModal\")\n  }\n\n  /** @returns {RouteDefinitions} */\n  getRouteDefinitions() {\n    return apiMakerConfigNotImplemented(\"getRouteDefinitions\")\n  }\n\n  /** @returns {RouteMap} */\n  getRoutes() {\n    return apiMakerConfigNotImplemented(\"getRoutes\")\n  }\n\n  /** @returns {boolean} */\n  getUseHtmlForm() {\n    return apiMakerConfigNotImplemented(\"getUseHtmlForm\")\n  }\n\n  /**\n   * @param {boolean} _newValue\n   */\n  setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented(\"setUseHtmlForm\") }\n\n  // Table export hooks. These hold functions that should be returned as-is (not invoked), so they use\n  // explicit accessors instead of the generic accessor loop below (which would call function values).\n\n  /**\n   * Opens a streaming file sink for table exports on platforms without a web default (e.g. React\n   * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink\n   * `{write(chunk), close(), abort()}`.\n   * @returns {((args: object) => Promise<object>) | undefined}\n   */\n  getExportFileSinkOpener() { return this.global.exportFileSinkOpener }\n\n  /**\n   * @param {((args: object) => Promise<object>) | undefined} opener\n   */\n  setExportFileSinkOpener(opener) { this.global.exportFileSinkOpener = opener }\n\n  /**\n   * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format\n   * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).\n   * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}\n   */\n  getExportXlsxSerializer() { return this.global.exportXlsxSerializer }\n\n  /**\n   * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer\n   */\n  setExportXlsxSerializer(serializer) { this.global.exportXlsxSerializer = serializer }\n}\n\nfor (const accessorName in accessors) {\n  const accessorData = accessors[accessorName]\n  const camelizedAccessor = inflection.camelize(accessorName)\n\n  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {\n    const oldValue = this.global[accessorName]\n\n    this.global[accessorName] = newValue\n\n    if (oldValue !== newValue) {\n      this.events.emit(`on${camelizedAccessor}Change`, {oldValue, newValue})\n    }\n  }\n\n  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {\n    if (this.global[accessorName] === undefined) {\n      if (accessorData.default !== undefined) return accessorData.default\n      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`)\n    }\n\n    const value = this.global[accessorName]\n\n    if (typeof value == \"function\") return value(...args)\n\n    return value\n  }\n}\n\nconst apiMakerConfig = new ApiMakerConfig()\n\nexport default apiMakerConfig\n"]}

package/build/table/export/cell-value.d.ts

@@ -0,0 +1,3 @@
+export function cellToText(value: unknown): string;
+export function cellToHtml(value: unknown): string;
+//# sourceMappingURL=cell-value.d.ts.map

package/build/table/export/cell-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-value.d.ts","sourceRoot":"/src/","sources":["table/export/cell-value.js"],"names":[],"mappings":"AAwCO,kCAHI,OAAO,GACL,MAAM,CAEwF;AAOpG,kCAHI,OAAO,GACL,MAAM,CAE+C"}

package/build/table/export/cell-value.js

@@ -0,0 +1,47 @@
+// @ts-check
+/* eslint-disable sort-imports */
+import React from "react";
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+const toText = (value) => (value === null || value === undefined ? "" : String(value));
+/**
+ * Recursively extracts the text content of a React node without rendering it, so the export path stays
+ * lightweight and SSR-/test-safe (no react-dom/server). A column's custom `content` can return a React
+ * element even in "html" mode; this keeps such cells exporting their text instead of "[object Object]".
+ * @param {unknown} node
+ * @returns {string}
+ */
+const reactNodeToText = (node) => {
+    if (node === null || node === undefined || typeof node === "boolean")
+        return "";
+    if (typeof node === "string" || typeof node === "number")
+        return String(node);
+    if (Array.isArray(node))
+        return node.map(reactNodeToText).join("");
+    if (React.isValidElement(node))
+        return reactNodeToText(/** @type {{props?: {children?: unknown}}} */ (node).props?.children);
+    return "";
+};
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+const escapeHtml = (text) => text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+/**
+ * Plain text value of a cell, for CSV/Excel.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export const cellToText = (value) => (React.isValidElement(value) ? reactNodeToText(value) : toText(value));
+/**
+ * HTML-escaped text value of a cell, for the HTML export.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export const cellToHtml = (value) => escapeHtml(cellToText(value));
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/file-sinks/web-file-sink.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @typedef {object} ExportFileSink
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsWritableStream
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsFileHandle
+ * @property {() => Promise<FsWritableStream>} createWritable
+ */
+/**
+ * @typedef {object} FsWindow
+ * @property {(options: object) => Promise<FsFileHandle>} [showSaveFilePicker]
+ */
+/**
+ * Opens a streaming file sink in the browser. When the File System Access API is available (Chromium), the
+ * export is written straight to the user-chosen file so memory stays bounded. Otherwise it falls back to
+ * buffering the chunks and saving a Blob via file-saver (memory-bound, but works everywhere).
+ *
+ * Must be called from within a user-gesture handler so the save-file picker is allowed to open.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @returns {Promise<ExportFileSink>}
+ */
+export default function openWebFileSink({ fileName, mimeType }: {
+    fileName: string;
+    mimeType: string;
+}): Promise<ExportFileSink>;
+export type ExportFileSink = {
+    write: (chunk: string | Uint8Array) => Promise<void>;
+    close: () => Promise<void>;
+    abort: () => Promise<void>;
+};
+export type FsWritableStream = {
+    write: (chunk: string | Uint8Array) => Promise<void>;
+    close: () => Promise<void>;
+    abort: () => Promise<void>;
+};
+export type FsFileHandle = {
+    createWritable: () => Promise<FsWritableStream>;
+};
+export type FsWindow = {
+    showSaveFilePicker?: (options: object) => Promise<FsFileHandle>;
+};
+//# sourceMappingURL=web-file-sink.d.ts.map

package/build/table/export/file-sinks/web-file-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-file-sink.d.ts","sourceRoot":"/src/","sources":["table/export/file-sinks/web-file-sink.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;;;;;GAKG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;;;;;GAWG;AACH,gEAJG;IAAqB,QAAQ,EAArB,MAAM;IACO,QAAQ,EAArB,MAAM;CACd,GAAU,OAAO,CAAC,cAAc,CAAC,CAgDnC;;WA7Ea,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;WAC7C,MAAM,OAAO,CAAC,IAAI,CAAC;WACnB,MAAM,OAAO,CAAC,IAAI,CAAC;;;WAInB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;WAC7C,MAAM,OAAO,CAAC,IAAI,CAAC;WACnB,MAAM,OAAO,CAAC,IAAI,CAAC;;;oBAInB,MAAM,OAAO,CAAC,gBAAgB,CAAC;;;yBAI/B,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC"}

package/build/table/export/file-sinks/web-file-sink.js

@@ -0,0 +1,75 @@
+// @ts-check
+import { saveAs } from "file-saver";
+/**
+ * @typedef {object} ExportFileSink
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsWritableStream
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsFileHandle
+ * @property {() => Promise<FsWritableStream>} createWritable
+ */
+/**
+ * @typedef {object} FsWindow
+ * @property {(options: object) => Promise<FsFileHandle>} [showSaveFilePicker]
+ */
+/**
+ * Opens a streaming file sink in the browser. When the File System Access API is available (Chromium), the
+ * export is written straight to the user-chosen file so memory stays bounded. Otherwise it falls back to
+ * buffering the chunks and saving a Blob via file-saver (memory-bound, but works everywhere).
+ *
+ * Must be called from within a user-gesture handler so the save-file picker is allowed to open.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @returns {Promise<ExportFileSink>}
+ */
+export default async function openWebFileSink({ fileName, mimeType }) {
+    const win = /** @type {FsWindow | undefined} */ (typeof window === "undefined" ? undefined : /** @type {unknown} */ (window));
+    if (win && typeof win.showSaveFilePicker === "function") {
+        const extension = fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".")) : "";
+        try {
+            const handle = await win.showSaveFilePicker({
+                suggestedName: fileName,
+                types: extension ? [{ accept: { [mimeType]: [extension] } }] : undefined
+            });
+            const writable = await handle.createWritable();
+            return {
+                write: (chunk) => writable.write(chunk),
+                close: () => writable.close(),
+                abort: () => writable.abort()
+            };
+        }
+        catch (error) {
+            // The user cancelled the picker - propagate so the export aborts quietly.
+            if (error && /** @type {Error} */ (error).name === "AbortError")
+                throw error;
+            // Any other problem (e.g. picker not usable in this context): fall back to the Blob path below.
+        }
+    }
+    /** @type {Array<string | Uint8Array>} */
+    const chunks = [];
+    return {
+        write: (chunk) => {
+            chunks.push(chunk);
+            return Promise.resolve();
+        },
+        close: () => {
+            saveAs(new Blob(chunks, { type: mimeType }), fileName);
+            return Promise.resolve();
+        },
+        abort: () => {
+            chunks.length = 0;
+            return Promise.resolve();
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/csv-writer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Streaming CSV writer. Emits one chunk per call so the export driver can write each page straight to the
+ * file sink without holding the whole document in memory. RFC-4180 quoting, CRLF line breaks, and a UTF-8 BOM
+ * so Excel opens it with the right encoding.
+ */
+export default class ApiMakerTableExportCsvWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels: Array<string>): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values: Array<unknown>): string;
+    /** @returns {string} */
+    footer(): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    line(values: Array<unknown>): string;
+    /**
+     * @param {unknown} value
+     * @returns {string}
+     */
+    escape(value: unknown): string;
+}
+//# sourceMappingURL=csv-writer.d.ts.map

package/build/table/export/format-writers/csv-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/csv-writer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACE;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAIlB;IAED,wBAAwB;IACxB,UADc,MAAM,CAGnB;IAED;;;OAGG;IACH,aAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,MAAM,CAUlB;CACF"}

package/build/table/export/format-writers/csv-writer.js

@@ -0,0 +1,47 @@
+// @ts-check
+import { cellToText } from "../cell-value.js";
+const UTF8_BOM = "";
+/**
+ * Streaming CSV writer. Emits one chunk per call so the export driver can write each page straight to the
+ * file sink without holding the whole document in memory. RFC-4180 quoting, CRLF line breaks, and a UTF-8 BOM
+ * so Excel opens it with the right encoding.
+ */
+export default class ApiMakerTableExportCsvWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels) {
+        return UTF8_BOM + this.line(labels);
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values) {
+        return this.line(values);
+    }
+    /** @returns {string} */
+    footer() {
+        return "";
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    line(values) {
+        return `${values.map((value) => this.escape(value)).join(",")}\r\n`;
+    }
+    /**
+     * @param {unknown} value
+     * @returns {string}
+     */
+    escape(value) {
+        const text = cellToText(value);
+        if ((/["\r\n,]/).test(text)) {
+            return `"${text.replace(/"/g, "\"\"")}"`;
+        }
+        return text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/html-writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Streaming HTML-table writer. Emits the table head, one `<tr>` per row, and the closing tags as separate
+ * chunks so the export driver can write each page to the file sink incrementally. Cells that are React
+ * elements (from a column's custom `content`) are rendered to markup; other values are escaped text.
+ */
+export default class ApiMakerTableExportHtmlWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels: Array<string>): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values: Array<unknown>): string;
+    /** @returns {string} */
+    footer(): string;
+}
+//# sourceMappingURL=html-writer.d.ts.map

package/build/table/export/format-writers/html-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/html-writer.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IACE;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAMlB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAMlB;IAED,wBAAwB;IACxB,UADc,MAAM,CAGnB;CACF"}

package/build/table/export/format-writers/html-writer.js

@@ -0,0 +1,30 @@
+// @ts-check
+import { cellToHtml } from "../cell-value.js";
+/**
+ * Streaming HTML-table writer. Emits the table head, one `<tr>` per row, and the closing tags as separate
+ * chunks so the export driver can write each page to the file sink incrementally. Cells that are React
+ * elements (from a column's custom `content`) are rendered to markup; other values are escaped text.
+ */
+export default class ApiMakerTableExportHtmlWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels) {
+        const cells = labels.map((label) => `<th>${cellToHtml(label)}</th>`).join("");
+        return `<table><thead><tr>${cells}</tr></thead><tbody>`;
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values) {
+        const cells = values.map((value) => `<td>${cellToHtml(value)}</td>`).join("");
+        return `<tr>${cells}</tr>`;
+    }
+    /** @returns {string} */
+    footer() {
+        return "</tbody></table>";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/xlsx-writer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Excel (.xlsx) writer. xlsx is a zipped binary that can't be appended chunk-by-chunk, so this buffers the
+ * rows and serializes the whole workbook in `footer()`. To keep api_maker free of a heavy spreadsheet
+ * dependency, the actual serialization is provided by the host app via
+ * `apiMakerConfig.setExportXlsxSerializer(rows => Uint8Array)`. Best for moderate row counts — use CSV for
+ * very large exports.
+ */
+export default class ApiMakerTableExportXlsxWriter {
+    rows: unknown[][];
+    /**
+     * @param {Array<string>} labels
+     * @returns {null}
+     */
+    header(labels: Array<string>): null;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {null}
+     */
+    row(values: Array<unknown>): null;
+    /** @returns {Promise<Uint8Array>} */
+    footer(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=xlsx-writer.d.ts.map

package/build/table/export/format-writers/xlsx-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlsx-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/xlsx-writer.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAEI,kBAAqD;IAGvD;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,IAAI,CAMhB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,IAAI,CAMhB;IAED,qCAAqC;IACrC,UADc,OAAO,CAAC,UAAU,CAAC,CAShC;CACF"}

package/build/table/export/format-writers/xlsx-writer.js

@@ -0,0 +1,41 @@
+// @ts-check
+/* eslint-disable sort-imports */
+import apiMakerConfig from "../../../config.js";
+import { cellToText } from "../cell-value.js";
+/**
+ * Excel (.xlsx) writer. xlsx is a zipped binary that can't be appended chunk-by-chunk, so this buffers the
+ * rows and serializes the whole workbook in `footer()`. To keep api_maker free of a heavy spreadsheet
+ * dependency, the actual serialization is provided by the host app via
+ * `apiMakerConfig.setExportXlsxSerializer(rows => Uint8Array)`. Best for moderate row counts — use CSV for
+ * very large exports.
+ */
+export default class ApiMakerTableExportXlsxWriter {
+    constructor() {
+        this.rows = /** @type {Array<Array<unknown>>} */ ([]);
+    }
+    /**
+     * @param {Array<string>} labels
+     * @returns {null}
+     */
+    header(labels) {
+        this.rows.push(labels);
+        return null;
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {null}
+     */
+    row(values) {
+        this.rows.push(values.map((value) => cellToText(value)));
+        return null;
+    }
+    /** @returns {Promise<Uint8Array>} */
+    async footer() {
+        const serializer = apiMakerConfig.getExportXlsxSerializer();
+        if (!serializer) {
+            throw new Error("Excel export isn't configured. Call apiMakerConfig.setExportXlsxSerializer(...) to enable it.");
+        }
+        return await serializer(this.rows);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/open-export-file-sink.d.ts

@@ -0,0 +1,19 @@
+/** @typedef {import("./file-sinks/web-file-sink.js").ExportFileSink} ExportFileSink */
+/**
+ * Opens a file sink for an export, abstracting over platforms. A host-configured opener (e.g. an
+ * expo-file-system/expo-sharing implementation on React Native) takes precedence; otherwise the built-in web
+ * sink is used. On native without a configured opener this throws with guidance.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @param {string} args.format
+ * @returns {Promise<ExportFileSink>}
+ */
+export default function openExportFileSink(args: {
+    fileName: string;
+    mimeType: string;
+    format: string;
+}): Promise<ExportFileSink>;
+export type ExportFileSink = import("./file-sinks/web-file-sink.js").ExportFileSink;
+//# sourceMappingURL=open-export-file-sink.d.ts.map

package/build/table/export/open-export-file-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-export-file-sink.d.ts","sourceRoot":"/src/","sources":["table/export/open-export-file-sink.js"],"names":[],"mappings":"AAKA,uFAAuF;AAEvF;;;;;;;;;;GAUG;AACH,iDALG;IAAqB,QAAQ,EAArB,MAAM;IACO,QAAQ,EAArB,MAAM;IACO,MAAM,EAAnB,MAAM;CACd,GAAU,OAAO,CAAC,cAAc,CAAC,CAYnC;6BAvBa,OAAO,+BAA+B,EAAE,cAAc"}

package/build/table/export/open-export-file-sink.js

@@ -0,0 +1,26 @@
+// @ts-check
+import { Platform } from "react-native";
+import apiMakerConfig from "../../config.js";
+import openWebFileSink from "./file-sinks/web-file-sink.js";
+/** @typedef {import("./file-sinks/web-file-sink.js").ExportFileSink} ExportFileSink */
+/**
+ * Opens a file sink for an export, abstracting over platforms. A host-configured opener (e.g. an
+ * expo-file-system/expo-sharing implementation on React Native) takes precedence; otherwise the built-in web
+ * sink is used. On native without a configured opener this throws with guidance.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @param {string} args.format
+ * @returns {Promise<ExportFileSink>}
+ */
+export default async function openExportFileSink(args) {
+    const configuredOpener = apiMakerConfig.getExportFileSinkOpener();
+    if (configuredOpener)
+        return await configuredOpener(args);
+    if (Platform.OS === "web")
+        return await openWebFileSink(args);
+    throw new Error("No export file sink configured for this platform. On React Native/Expo, call " +
+        "apiMakerConfig.setExportFileSinkOpener(...) (e.g. using expo-file-system + expo-sharing).");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3Blbi1leHBvcnQtZmlsZS1zaW5rLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJ0YWJsZS9leHBvcnQvb3Blbi1leHBvcnQtZmlsZS1zaW5rLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFDWixPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sY0FBYyxDQUFBO0FBQ3JDLE9BQU8sY0FBYyxNQUFNLGlCQUFpQixDQUFBO0FBQzVDLE9BQU8sZUFBZSxNQUFNLCtCQUErQixDQUFBO0FBRTNELHVGQUF1RjtBQUV2Rjs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLFVBQVUsa0JBQWtCLENBQUMsSUFBSTtJQUNuRCxNQUFNLGdCQUFnQixHQUFHLGNBQWMsQ0FBQyx1QkFBdUIsRUFBRSxDQUFBO0lBRWpFLElBQUksZ0JBQWdCO1FBQUUsT0FBTyxNQUFNLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFBO0lBQ3pELElBQUksUUFBUSxDQUFDLEVBQUUsS0FBSyxLQUFLO1FBQUUsT0FBTyxNQUFNLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUU3RCxNQUFNLElBQUksS0FBSyxDQUNiLCtFQUErRTtRQUMvRSwyRkFBMkYsQ0FDNUYsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbmltcG9ydCB7UGxhdGZvcm19IGZyb20gXCJyZWFjdC1uYXRpdmVcIlxuaW1wb3J0IGFwaU1ha2VyQ29uZmlnIGZyb20gXCIuLi8uLi9jb25maWcuanNcIlxuaW1wb3J0IG9wZW5XZWJGaWxlU2luayBmcm9tIFwiLi9maWxlLXNpbmtzL3dlYi1maWxlLXNpbmsuanNcIlxuXG4vKiogQHR5cGVkZWYge2ltcG9ydChcIi4vZmlsZS1zaW5rcy93ZWItZmlsZS1zaW5rLmpzXCIpLkV4cG9ydEZpbGVTaW5rfSBFeHBvcnRGaWxlU2luayAqL1xuXG4vKipcbiAqIE9wZW5zIGEgZmlsZSBzaW5rIGZvciBhbiBleHBvcnQsIGFic3RyYWN0aW5nIG92ZXIgcGxhdGZvcm1zLiBBIGhvc3QtY29uZmlndXJlZCBvcGVuZXIgKGUuZy4gYW5cbiAqIGV4cG8tZmlsZS1zeXN0ZW0vZXhwby1zaGFyaW5nIGltcGxlbWVudGF0aW9uIG9uIFJlYWN0IE5hdGl2ZSkgdGFrZXMgcHJlY2VkZW5jZTsgb3RoZXJ3aXNlIHRoZSBidWlsdC1pbiB3ZWJcbiAqIHNpbmsgaXMgdXNlZC4gT24gbmF0aXZlIHdpdGhvdXQgYSBjb25maWd1cmVkIG9wZW5lciB0aGlzIHRocm93cyB3aXRoIGd1aWRhbmNlLlxuICpcbiAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzXG4gKiBAcGFyYW0ge3N0cmluZ30gYXJncy5maWxlTmFtZVxuICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MubWltZVR5cGVcbiAqIEBwYXJhbSB7c3RyaW5nfSBhcmdzLmZvcm1hdFxuICogQHJldHVybnMge1Byb21pc2U8RXhwb3J0RmlsZVNpbms+fVxuICovXG5leHBvcnQgZGVmYXVsdCBhc3luYyBmdW5jdGlvbiBvcGVuRXhwb3J0RmlsZVNpbmsoYXJncykge1xuICBjb25zdCBjb25maWd1cmVkT3BlbmVyID0gYXBpTWFrZXJDb25maWcuZ2V0RXhwb3J0RmlsZVNpbmtPcGVuZXIoKVxuXG4gIGlmIChjb25maWd1cmVkT3BlbmVyKSByZXR1cm4gYXdhaXQgY29uZmlndXJlZE9wZW5lcihhcmdzKVxuICBpZiAoUGxhdGZvcm0uT1MgPT09IFwid2ViXCIpIHJldHVybiBhd2FpdCBvcGVuV2ViRmlsZVNpbmsoYXJncylcblxuICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgXCJObyBleHBvcnQgZmlsZSBzaW5rIGNvbmZpZ3VyZWQgZm9yIHRoaXMgcGxhdGZvcm0uIE9uIFJlYWN0IE5hdGl2ZS9FeHBvLCBjYWxsIFwiICtcbiAgICBcImFwaU1ha2VyQ29uZmlnLnNldEV4cG9ydEZpbGVTaW5rT3BlbmVyKC4uLikgKGUuZy4gdXNpbmcgZXhwby1maWxlLXN5c3RlbSArIGV4cG8tc2hhcmluZykuXCJcbiAgKVxufVxuIl19

package/build/table/export/table-exporter.d.ts

@@ -0,0 +1,80 @@
+/** Thrown when the user cancels an in-progress export. */
+export class ApiMakerTableExportAbortedError extends Error {
+}
+/**
+ * Streams a table's whole result set to a file, fetching it page-by-page and writing each page straight to a
+ * file sink, so only one page (plus the format writer's own buffering) is ever held in memory.
+ *
+ * @typedef {object} ExporterArgs
+ * @property {number} [batchSize]
+ * @property {"csv" | "html" | "xlsx"} format
+ * @property {(format: string, value: Date) => string} l
+ * @property {(progress: {page: number, totalPages: number, written: number}) => void} [onProgress]
+ * @property {object} table
+ */
+export default class ApiMakerTableExporter {
+    /** @param {ExporterArgs} args */
+    constructor({ batchSize, format, l, onProgress, table }: ExporterArgs);
+    batchSize: number;
+    format: "html" | "csv" | "xlsx";
+    l: (format: string, value: Date) => string;
+    onProgress: (progress: {
+        page: number;
+        totalPages: number;
+        written: number;
+    }) => void;
+    table: any;
+    aborted: boolean;
+    abort(): void;
+    /** @returns {Promise<{written: number}>} */
+    run(): Promise<{
+        written: number;
+    }>;
+    /** @returns {Array<{column: object, tableSettingColumn: object}>} */
+    visibleColumns(): Array<{
+        column: object;
+        tableSettingColumn: object;
+    }>;
+    /**
+     * @param {{column: object}} preparedColumn
+     * @param {object} model
+     * @returns {unknown}
+     */
+    cellValue(preparedColumn: {
+        column: object;
+    }, model: object): unknown;
+    /** @returns {string} */
+    modelName(): string;
+    baseQuery(): any;
+    /**
+     * @param {{write: (chunk: string | Uint8Array) => Promise<void>}} sink
+     * @param {string | Uint8Array | null | undefined} chunk
+     * @returns {Promise<void>}
+     */
+    writeChunk(sink: {
+        write: (chunk: string | Uint8Array) => Promise<void>;
+    }, chunk: string | Uint8Array | null | undefined): Promise<void>;
+    /**
+     * @param {{abort: () => Promise<void>}} sink
+     * @returns {Promise<void>}
+     */
+    abortSink(sink: {
+        abort: () => Promise<void>;
+    }): Promise<void>;
+}
+/**
+ * Streams a table's whole result set to a file, fetching it page-by-page and writing each page straight to a
+ * file sink, so only one page (plus the format writer's own buffering) is ever held in memory.
+ */
+export type ExporterArgs = {
+    batchSize?: number;
+    format: "csv" | "html" | "xlsx";
+    l: (format: string, value: Date) => string;
+    onProgress?: (progress: {
+        page: number;
+        totalPages: number;
+        written: number;
+    }) => void;
+    table: object;
+};
+//# sourceMappingURL=table-exporter.d.ts.map

package/build/table/export/table-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-exporter.d.ts","sourceRoot":"/src/","sources":["table/export/table-exporter.js"],"names":[],"mappings":"AAkBA,0DAA0D;AAC1D;CAA6D;AAE7D;;;;;;;;;;GAUG;AACH;IACE,iCAAiC;IACjC,yDADY,YAAY,EAQvB;IANC,kBAA0B;IAC1B,gCAAoB;IACpB,YATmB,MAAM,SAAS,IAAI,KAAK,MAAM,CASvC;IACV,uBATqB;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,CASrD;IAC5B,WAAkB;IAClB,iBAAoB;IAGtB,cAEC;IAED,4CAA4C;IAC5C,OADc,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CA4DvC;IAED,qEAAqE;IACrE,kBADc,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAC,CAAC,CAKhE;IAED;;;;OAIG;IACH,0BAJW;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,SAChB,MAAM,GACJ,OAAO,CAInB;IAED,wBAAwB;IACxB,aADc,MAAM,CAGnB;IAED,iBAEC;IAED;;;;OAIG;IACH,iBAJW;QAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAC,SACtD,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,OAAO,CAAC,IAAI,CAAC,CAOzB;IAED;;;OAGG;IACH,gBAHW;QAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAC,GAC1B,OAAO,CAAC,IAAI,CAAC,CAQzB;CACF;;;;;;gBAnIa,MAAM;YACN,KAAK,GAAG,MAAM,GAAG,MAAM;OACvB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,KAAK,MAAM;iBACvC,CAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI;WACvE,MAAM"}

package/build/table/export/table-exporter.js

@@ -0,0 +1,141 @@
+// @ts-check
+// The export is intentionally sequential: each page is fetched and written before the next so only one page
+// is ever in memory. That requires awaiting inside the paging loop.
+/* eslint-disable no-await-in-loop, sort-imports */
+import { digg } from "diggerize";
+import columnVisible from "../column-visible.js";
+import ColumnContent from "../column-content";
+import CsvWriter from "./format-writers/csv-writer.js";
+import HtmlWriter from "./format-writers/html-writer.js";
+import openExportFileSink from "./open-export-file-sink.js";
+import XlsxWriter from "./format-writers/xlsx-writer.js";
+const FORMATS = {
+    csv: { extension: "csv", mimeType: "text/csv;charset=utf-8", Writer: CsvWriter },
+    html: { extension: "html", mimeType: "text/html;charset=utf-8", Writer: HtmlWriter },
+    xlsx: { extension: "xlsx", mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", Writer: XlsxWriter }
+};
+/** Thrown when the user cancels an in-progress export. */
+export class ApiMakerTableExportAbortedError extends Error {
+}
+/**
+ * Streams a table's whole result set to a file, fetching it page-by-page and writing each page straight to a
+ * file sink, so only one page (plus the format writer's own buffering) is ever held in memory.
+ *
+ * @typedef {object} ExporterArgs
+ * @property {number} [batchSize]
+ * @property {"csv" | "html" | "xlsx"} format
+ * @property {(format: string, value: Date) => string} l
+ * @property {(progress: {page: number, totalPages: number, written: number}) => void} [onProgress]
+ * @property {object} table
+ */
+export default class ApiMakerTableExporter {
+    /** @param {ExporterArgs} args */
+    constructor({ batchSize = 1000, format, l, onProgress, table }) {
+        this.batchSize = batchSize;
+        this.format = format;
+        this.l = l;
+        this.onProgress = onProgress;
+        this.table = table;
+        this.aborted = false;
+    }
+    abort() {
+        this.aborted = true;
+    }
+    /** @returns {Promise<{written: number}>} */
+    async run() {
+        const formatConfig = FORMATS[this.format];
+        if (!formatConfig)
+            throw new Error(`Unknown export format: ${this.format}`);
+        const writer = new formatConfig.Writer();
+        const columns = this.visibleColumns();
+        const labels = columns.map((preparedColumn) => this.table.headerLabelForColumn(preparedColumn.column));
+        const fileName = `${this.modelName()}.${formatConfig.extension}`;
+        const sink = await openExportFileSink({ fileName, format: this.format, mimeType: formatConfig.mimeType });
+        let written = 0;
+        try {
+            await this.writeChunk(sink, writer.header(labels));
+            let page = 1;
+            let totalPages = 1;
+            do {
+                const result = await this.baseQuery()
+                    .clone()
+                    .page(page)
+                    .per(this.batchSize)
+                    .result();
+                if (page === 1)
+                    totalPages = result.totalPages();
+                let buffer = "";
+                for (const model of result.models()) {
+                    if (this.aborted)
+                        throw new ApiMakerTableExportAbortedError("Export aborted");
+                    const values = columns.map((preparedColumn) => this.cellValue(preparedColumn, model));
+                    const chunk = writer.row(values);
+                    if (typeof chunk === "string") {
+                        buffer += chunk;
+                    }
+                    else if (chunk !== null && chunk !== undefined) {
+                        await this.writeChunk(sink, chunk);
+                    }
+                    written += 1;
+                }
+                if (buffer.length > 0)
+                    await sink.write(buffer);
+                if (this.onProgress)
+                    this.onProgress({ page, totalPages, written });
+                page += 1;
+            } while (page <= totalPages);
+            await this.writeChunk(sink, await writer.footer());
+            await sink.close();
+            return { written };
+        }
+        catch (error) {
+            await this.abortSink(sink);
+            throw error;
+        }
+    }
+    /** @returns {Array<{column: object, tableSettingColumn: object}>} */
+    visibleColumns() {
+        const preparedColumns = this.table.s.preparedColumns || [];
+        return preparedColumns.filter(({ column, tableSettingColumn }) => columnVisible(column, tableSettingColumn));
+    }
+    /**
+     * @param {{column: object}} preparedColumn
+     * @param {object} model
+     * @returns {unknown}
+     */
+    cellValue(preparedColumn, model) {
+        return new ColumnContent({ column: preparedColumn.column, l: this.l, mode: "html", model, table: this.table }).content();
+    }
+    /** @returns {string} */
+    modelName() {
+        return this.table.p.modelClass.modelName().human({ count: 2 });
+    }
+    baseQuery() {
+        return digg(this.table.tt.collection, "query");
+    }
+    /**
+     * @param {{write: (chunk: string | Uint8Array) => Promise<void>}} sink
+     * @param {string | Uint8Array | null | undefined} chunk
+     * @returns {Promise<void>}
+     */
+    async writeChunk(sink, chunk) {
+        if (chunk === null || chunk === undefined)
+            return;
+        if (typeof chunk === "string" && chunk.length === 0)
+            return;
+        await sink.write(chunk);
+    }
+    /**
+     * @param {{abort: () => Promise<void>}} sink
+     * @returns {Promise<void>}
+     */
+    async abortSink(sink) {
+        try {
+            await sink.abort();
+        }
+        catch {
+            // Ignore secondary errors while cleaning up after a failed/aborted export.
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-exporter.js","sourceRoot":"/src/","sources":["table/export/table-exporter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n// The export is intentionally sequential: each page is fetched and written before the next so only one page\n// is ever in memory. That requires awaiting inside the paging loop.\n/* eslint-disable no-await-in-loop, sort-imports */\nimport {digg} from \"diggerize\"\nimport columnVisible from \"../column-visible.js\"\nimport ColumnContent from \"../column-content\"\nimport CsvWriter from \"./format-writers/csv-writer.js\"\nimport HtmlWriter from \"./format-writers/html-writer.js\"\nimport openExportFileSink from \"./open-export-file-sink.js\"\nimport XlsxWriter from \"./format-writers/xlsx-writer.js\"\n\nconst FORMATS = {\n  csv: {extension: \"csv\", mimeType: \"text/csv;charset=utf-8\", Writer: CsvWriter},\n  html: {extension: \"html\", mimeType: \"text/html;charset=utf-8\", Writer: HtmlWriter},\n  xlsx: {extension: \"xlsx\", mimeType: \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\", Writer: XlsxWriter}\n}\n\n/** Thrown when the user cancels an in-progress export. */\nexport class ApiMakerTableExportAbortedError extends Error {}\n\n/**\n * Streams a table's whole result set to a file, fetching it page-by-page and writing each page straight to a\n * file sink, so only one page (plus the format writer's own buffering) is ever held in memory.\n *\n * @typedef {object} ExporterArgs\n * @property {number} [batchSize]\n * @property {\"csv\" | \"html\" | \"xlsx\"} format\n * @property {(format: string, value: Date) => string} l\n * @property {(progress: {page: number, totalPages: number, written: number}) => void} [onProgress]\n * @property {object} table\n */\nexport default class ApiMakerTableExporter {\n  /** @param {ExporterArgs} args */\n  constructor({batchSize = 1000, format, l, onProgress, table}) {\n    this.batchSize = batchSize\n    this.format = format\n    this.l = l\n    this.onProgress = onProgress\n    this.table = table\n    this.aborted = false\n  }\n\n  abort() {\n    this.aborted = true\n  }\n\n  /** @returns {Promise<{written: number}>} */\n  async run() {\n    const formatConfig = FORMATS[this.format]\n\n    if (!formatConfig) throw new Error(`Unknown export format: ${this.format}`)\n\n    const writer = new formatConfig.Writer()\n    const columns = this.visibleColumns()\n    const labels = columns.map((preparedColumn) => this.table.headerLabelForColumn(preparedColumn.column))\n    const fileName = `${this.modelName()}.${formatConfig.extension}`\n    const sink = await openExportFileSink({fileName, format: this.format, mimeType: formatConfig.mimeType})\n    let written = 0\n\n    try {\n      await this.writeChunk(sink, writer.header(labels))\n\n      let page = 1\n      let totalPages = 1\n\n      do {\n        const result = await this.baseQuery()\n          .clone()\n          .page(page)\n          .per(this.batchSize)\n          .result()\n\n        if (page === 1) totalPages = result.totalPages()\n\n        let buffer = \"\"\n\n        for (const model of result.models()) {\n          if (this.aborted) throw new ApiMakerTableExportAbortedError(\"Export aborted\")\n\n          const values = columns.map((preparedColumn) => this.cellValue(preparedColumn, model))\n          const chunk = writer.row(values)\n\n          if (typeof chunk === \"string\") {\n            buffer += chunk\n          } else if (chunk !== null && chunk !== undefined) {\n            await this.writeChunk(sink, chunk)\n          }\n\n          written += 1\n        }\n\n        if (buffer.length > 0) await sink.write(buffer)\n        if (this.onProgress) this.onProgress({page, totalPages, written})\n\n        page += 1\n      } while (page <= totalPages)\n\n      await this.writeChunk(sink, await writer.footer())\n      await sink.close()\n\n      return {written}\n    } catch (error) {\n      await this.abortSink(sink)\n\n      throw error\n    }\n  }\n\n  /** @returns {Array<{column: object, tableSettingColumn: object}>} */\n  visibleColumns() {\n    const preparedColumns = this.table.s.preparedColumns || []\n\n    return preparedColumns.filter(({column, tableSettingColumn}) => columnVisible(column, tableSettingColumn))\n  }\n\n  /**\n   * @param {{column: object}} preparedColumn\n   * @param {object} model\n   * @returns {unknown}\n   */\n  cellValue(preparedColumn, model) {\n    return new ColumnContent({column: preparedColumn.column, l: this.l, mode: \"html\", model, table: this.table}).content()\n  }\n\n  /** @returns {string} */\n  modelName() {\n    return this.table.p.modelClass.modelName().human({count: 2})\n  }\n\n  baseQuery() {\n    return digg(this.table.tt.collection, \"query\")\n  }\n\n  /**\n   * @param {{write: (chunk: string | Uint8Array) => Promise<void>}} sink\n   * @param {string | Uint8Array | null | undefined} chunk\n   * @returns {Promise<void>}\n   */\n  async writeChunk(sink, chunk) {\n    if (chunk === null || chunk === undefined) return\n    if (typeof chunk === \"string\" && chunk.length === 0) return\n\n    await sink.write(chunk)\n  }\n\n  /**\n   * @param {{abort: () => Promise<void>}} sink\n   * @returns {Promise<void>}\n   */\n  async abortSink(sink) {\n    try {\n      await sink.abort()\n    } catch {\n      // Ignore secondary errors while cleaning up after a failed/aborted export.\n    }\n  }\n}\n"]}

package/build/table/settings/download-action.d.ts

@@ -1,9 +1,16 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+/**
+ * Streams the whole table result set to a file (CSV / HTML / Excel) instead of building one big string in
+ * memory. Excel is only offered when the host app has registered an xlsx serializer via
+ * apiMakerConfig.setExportXlsxSerializer.
+ */
 export type Props = {
     l: Function;
     table: object;
 };
-export type State = Record<string, never>;
+export type State = {
+    exporting: boolean;
+};
 import React from "react";
 //# sourceMappingURL=download-action.d.ts.map

package/build/table/settings/download-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"download-action.d.ts","sourceRoot":"/src/","sources":["table/settings/download-action.jsx"],"names":[],"mappings":";;;;WAmBc,MAAM;;oBAEN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBAXjB,OAAO"}
+{"version":3,"file":"download-action.d.ts","sourceRoot":"/src/","sources":["table/settings/download-action.jsx"],"names":[],"mappings":";;;;;;;;;WAsBc,MAAM;;oBAEN;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC;kBAbhB,OAAO"}

package/build/table/settings/download-action.js

@@ -1,46 +1,73 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // @ts-check
-/* eslint-disable implicit-arrow-linebreak, react/jsx-no-literals, sort-imports */
-import ColumnContent from "../column-content";
-import columnIdentifier from "../column-identifier.js";
-import columnVisible from "../column-visible.js";
-import { saveAs } from "file-saver";
+/* eslint-disable sort-imports */
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
+import { FlashNotifications } from "flash-notifications";
+import { Pressable, View } from "react-native";
+import apiMakerConfig from "../../config.js";
+import ApiMakerTableExporter, { ApiMakerTableExportAbortedError } from "../export/table-exporter";
 import Icon from "../../utils/icon";
 import memo from "set-state-compare/build/memo.js";
 import PropTypes from "prop-types";
 import propTypesExact from "prop-types-exact";
 import React from "react";
-import { renderToString } from "react-dom/server"; // eslint-disable-line import/no-unresolved
-import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
-import { Pressable } from "react-native";
 import Text from "../../utils/text";
+import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
 /**
+ * Streams the whole table result set to a file (CSV / HTML / Excel) instead of building one big string in
+ * memory. Excel is only offered when the host app has registered an xlsx serializer via
+ * apiMakerConfig.setExportXlsxSerializer.
+ *
  * @typedef {object} Props
  * @property {Function} l
  * @property {object} table
  */
-/** @typedef {Record<string, never>} State */
+/** @typedef {{exporting: boolean}} State */
 export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableSettingsDownloadAction extends ShapeComponent {
     static propTypes = propTypesExact({
         l: PropTypes.func.isRequired,
         table: PropTypes.object.isRequired
     });
+    state = {
+        exporting: false
+    };
+    setup() {
+        const { t } = useI18n({ namespace: "js.api_maker.table.download_action" });
+        this.t = t;
+    }
     render() {
-        return (_jsxs(Pressable, { dataSet: this.cache("pressableDataSet", { component: "api-maker/table/settings/download-action" }), onPress: this.tt.onDownloadPress, style: this.cache("pressableStyle", { flexDirection: "row", alignItems: "center" }), children: [_jsx(Icon, { name: "download", size: 20 }), _jsx(Text, { style: this.cache("textStyle", { marginLeft: 5 }), children: "Download" })] }));
+        const excelAvailable = Boolean(apiMakerConfig.getExportXlsxSerializer());
+        return (_jsxs(View, { dataSet: this.cache("rootViewDataSet", { component: "api-maker/table/settings/download-action" }), children: [_jsx(Text, { style: this.cache("labelStyle", { fontWeight: "bold", marginBottom: 4 }), children: this.t(".download", { defaultValue: "Download" }) }), this.formatButton({ format: "csv", label: "CSV", onPress: this.tt.onDownloadCsv }), this.formatButton({ format: "html", label: "HTML", onPress: this.tt.onDownloadHtml }), excelAvailable && this.formatButton({ format: "xlsx", label: "Excel", onPress: this.tt.onDownloadXlsx })] }));
+    }
+    /**
+     * @param {{format: "csv" | "html" | "xlsx", label: string, onPress: () => void}} args
+     * @returns {import("react").ReactNode}
+     */
+    formatButton({ format, label, onPress }) {
+        return (_jsxs(Pressable, { dataSet: this.cache(`download${format}DataSet`, { component: `api-maker/table/settings/download-action/${format}` }), disabled: this.s.exporting, onPress: onPress, style: this.cache("formatButtonStyle", { flexDirection: "row", alignItems: "center", paddingVertical: 3 }), testID: `download-action-${format}`, children: [_jsx(Icon, { name: "download", size: 18 }), _jsx(Text, { style: this.cache("formatLabelStyle", { marginLeft: 5 }), children: label })] }));
     }
-    onDownloadPress = () => {
-        const { l, table } = this.p;
-        const { modelClass } = table.p;
-        const { collection } = table.tt;
-        const { models } = collection;
-        const { preparedColumns } = table.s;
-        const tableElement = (_jsxs("table", { children: [_jsx("thead", { children: _jsx("tr", { children: preparedColumns?.map(({ column, tableSettingColumn }) => columnVisible(column, tableSettingColumn) &&
-                            _jsx("th", { children: table.headerLabelForColumn(column) }, columnIdentifier(column))) }) }), _jsx("tbody", { children: models.map((model) => _jsx("tr", { children: preparedColumns?.map(({ column, tableSettingColumn }) => columnVisible(column, tableSettingColumn) &&
-                            _jsx("td", { children: new ColumnContent({ column, l, mode: "html", model, table }).content() }, columnIdentifier(column))) }, model.id())) })] }));
-        const tableHTML = renderToString(tableElement);
-        const blob = new Blob([tableHTML], { type: "text/html;charset=utf-8" });
-        const fileName = `${modelClass.modelName().human({ count: 2 })}.html`;
-        saveAs(blob, fileName);
+    onDownloadCsv = () => this.startExport("csv");
+    onDownloadHtml = () => this.startExport("html");
+    onDownloadXlsx = () => this.startExport("xlsx");
+    /** @param {"csv" | "html" | "xlsx"} format */
+    startExport = async (format) => {
+        if (this.s.exporting)
+            return;
+        this.s.exporting = true;
+        const exporter = new ApiMakerTableExporter({ format, l: this.p.l, table: this.p.table });
+        try {
+            await exporter.run();
+        }
+        catch (error) {
+            if (error instanceof ApiMakerTableExportAbortedError)
+                return;
+            if (error && /** @type {Error} */ (error).name === "AbortError")
+                return;
+            FlashNotifications.errorResponse(error);
+        }
+        finally {
+            this.s.exporting = false;
+        }
     };
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"download-action.js","sourceRoot":"/src/","sources":["table/settings/download-action.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports */\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport {Pressable, View} from \"react-native\"\nimport apiMakerConfig from \"../../config.js\"\nimport ApiMakerTableExporter, {ApiMakerTableExportAbortedError} from \"../export/table-exporter\"\nimport Icon from \"../../utils/icon\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport React from \"react\"\nimport Text from \"../../utils/text\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\n\n/**\n * Streams the whole table result set to a file (CSV / HTML / Excel) instead of building one big string in\n * memory. Excel is only offered when the host app has registered an xlsx serializer via\n * apiMakerConfig.setExportXlsxSerializer.\n *\n * @typedef {object} Props\n * @property {Function} l\n * @property {object} table\n */\n/** @typedef {{exporting: boolean}} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableSettingsDownloadAction extends ShapeComponent {\n  static propTypes = propTypesExact({\n    l: PropTypes.func.isRequired,\n    table: PropTypes.object.isRequired\n  })\n\n  state = {\n    exporting: false\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.download_action\"})\n\n    this.t = t\n  }\n\n  render() {\n    const excelAvailable = Boolean(apiMakerConfig.getExportXlsxSerializer())\n\n    return (\n      <View dataSet={this.cache(\"rootViewDataSet\", {component: \"api-maker/table/settings/download-action\"})}>\n        <Text style={this.cache(\"labelStyle\", {fontWeight: \"bold\", marginBottom: 4})}>\n          {this.t(\".download\", {defaultValue: \"Download\"})}\n        </Text>\n        {this.formatButton({format: \"csv\", label: \"CSV\", onPress: this.tt.onDownloadCsv})}\n        {this.formatButton({format: \"html\", label: \"HTML\", onPress: this.tt.onDownloadHtml})}\n        {excelAvailable && this.formatButton({format: \"xlsx\", label: \"Excel\", onPress: this.tt.onDownloadXlsx})}\n      </View>\n    )\n  }\n\n  /**\n   * @param {{format: \"csv\" | \"html\" | \"xlsx\", label: string, onPress: () => void}} args\n   * @returns {import(\"react\").ReactNode}\n   */\n  formatButton({format, label, onPress}) {\n    return (\n      <Pressable\n        dataSet={this.cache(`download${format}DataSet`, {component: `api-maker/table/settings/download-action/${format}`})}\n        disabled={this.s.exporting}\n        onPress={onPress}\n        style={this.cache(\"formatButtonStyle\", {flexDirection: \"row\", alignItems: \"center\", paddingVertical: 3})}\n        testID={`download-action-${format}`}\n      >\n        <Icon name=\"download\" size={18} />\n        <Text style={this.cache(\"formatLabelStyle\", {marginLeft: 5})}>\n          {label}\n        </Text>\n      </Pressable>\n    )\n  }\n\n  onDownloadCsv = () => this.startExport(\"csv\")\n  onDownloadHtml = () => this.startExport(\"html\")\n  onDownloadXlsx = () => this.startExport(\"xlsx\")\n\n  /** @param {\"csv\" | \"html\" | \"xlsx\"} format */\n  startExport = async (format) => {\n    if (this.s.exporting) return\n\n    this.s.exporting = true\n\n    const exporter = new ApiMakerTableExporter({format, l: this.p.l, table: this.p.table})\n\n    try {\n      await exporter.run()\n    } catch (error) {\n      if (error instanceof ApiMakerTableExportAbortedError) return\n      if (error && /** @type {Error} */ (error).name === \"AbortError\") return\n\n      FlashNotifications.errorResponse(error)\n    } finally {\n      this.s.exporting = false\n    }\n  }\n}))\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaspernj/api-maker",
   "type": "module",
-  "version": "1.0.2171",
+  "version": "1.0.2172",
   "description": "My new module",
   "files": [
     "build/**"