@kaspernj/api-maker 1.0.2170 → 1.0.2172

package/build/bootstrap/invalid-feedback.d.ts

@@ -1,8 +1,11 @@
 export default class ApiMakerBootstrapInvalidFeedback extends React.PureComponent<any, any, any> {
-    static propTypes: ValidationMap<T>;
+    static propTypes: PropTypes.ValidationMap<{
+        errors: any[];
+    }>;
     constructor(props: any);
     render(): import("react/jsx-runtime").JSX.Element;
     errorMessages(): any[];
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=invalid-feedback.d.ts.map

package/build/bootstrap/invalid-feedback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-feedback.d.ts","sourceRoot":"/src/","sources":["bootstrap/invalid-feedback.jsx"],"names":[],"mappings":"AAMA;IACE,mCAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO"}
+{"version":3,"file":"invalid-feedback.d.ts","sourceRoot":"/src/","sources":["bootstrap/invalid-feedback.jsx"],"names":[],"mappings":"AAMA;IACE;;OAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO;sBAFH,YAAY"}

package/build/config.d.ts

@@ -32,6 +32,12 @@ declare class ApiMakerConfig {
     getHost(): string;
     /** @returns {string | undefined} */
     getCableUrl(): string | undefined;
+    /** @returns {number} */
+    getDangerousRowCountThreshold(): number;
+    /**
+     * @param {number} _newValue
+     */
+    setDangerousRowCountThreshold(_newValue: number): void;
     /**
      * @param {string | undefined} _newValue
      */
@@ -56,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;AA8InD,6CAA2C;6BA1JhB,eAAe;AAiD1C,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;;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

@@ -26,6 +26,7 @@ const accessors = {
     },
     cableUrl: { require: false },
     currenciesCollection: { required: true },
+    dangerousRowCountThreshold: { default: 1000, required: false },
     history: { required: true },
     host: { required: false },
     i18n: { required: false },
@@ -70,6 +71,14 @@ class ApiMakerConfig {
     getCableUrl() {
         return apiMakerConfigNotImplemented("getCableUrl");
     }
+    /** @returns {number} */
+    getDangerousRowCountThreshold() {
+        return apiMakerConfigNotImplemented("getDangerousRowCountThreshold");
+    }
+    /**
+     * @param {number} _newValue
+     */
+    setDangerousRowCountThreshold(_newValue) { apiMakerConfigNotImplemented("setDangerousRowCountThreshold"); }
     /**
      * @param {string | undefined} _newValue
      */
@@ -106,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];
@@ -132,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  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  /**\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/event-connection.d.ts

@@ -2,7 +2,12 @@ export default class ApiMakerEventConnection extends React.PureComponent<any, an
     static defaultProps: {
         active: boolean;
     };
-    static propTypes: ValidationMap<T>;
+    static propTypes: PropTypes.ValidationMap<{
+        active: boolean;
+        model: object;
+        event: string;
+        onCall: (...args: any[]) => any;
+    }>;
     constructor(props: any);
     componentDidMount(): void;
     subscription: import("./cable-subscription.js").default;
@@ -11,4 +16,5 @@ export default class ApiMakerEventConnection extends React.PureComponent<any, an
     onCall(...args: any[]): void;
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=event-connection.d.ts.map

package/build/event-connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED,mCAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO"}
+{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED;;;;;OAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO;sBADH,YAAY"}

package/build/event-model-class.d.ts

@@ -1,5 +1,9 @@
 export default class ApiMakerEventModelClass extends React.PureComponent<any, any, any> {
-    static propTypes: ValidationMap<T>;
+    static propTypes: PropTypes.ValidationMap<{
+        event: string;
+        modelClass: (...args: any[]) => any;
+        onCall: (...args: any[]) => any;
+    }>;
     constructor(props: any);
     componentDidMount(): void;
     componentWillUnmount(): void;
@@ -8,4 +12,5 @@ export default class ApiMakerEventModelClass extends React.PureComponent<any, an
     render(): any;
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=event-model-class.d.ts.map

package/build/event-model-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE,mCAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO"}
+{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE;;;;OAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO;sBADH,YAAY"}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3N2LXdyaXRlci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidGFibGUvZXhwb3J0L2Zvcm1hdC13cml0ZXJzL2Nzdi13cml0ZXIuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQTtBQUUzQyxNQUFNLFFBQVEsR0FBRyxHQUFHLENBQUE7QUFFcEI7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sNEJBQTRCO0lBQy9DOzs7T0FHRztJQUNILE1BQU0sQ0FBQyxNQUFNO1FBQ1gsT0FBTyxRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUNyQyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsR0FBRyxDQUFDLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDMUIsQ0FBQztJQUVELHdCQUF3QjtJQUN4QixNQUFNO1FBQ0osT0FBTyxFQUFFLENBQUE7SUFDWCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsSUFBSSxDQUFDLE1BQU07UUFDVCxPQUFPLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFBO0lBQ3JFLENBQUM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsS0FBSztRQUNWLE1BQU0sSUFBSSxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUU5QixJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDNUIsT0FBTyxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUE7UUFDMUMsQ0FBQztRQUVELE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5pbXBvcnQge2NlbGxUb1RleHR9IGZyb20gXCIuLi9jZWxsLXZhbHVlLmpzXCJcblxuY29uc3QgVVRGOF9CT00gPSBcIu+7v1wiXG5cbi8qKlxuICogU3RyZWFtaW5nIENTViB3cml0ZXIuIEVtaXRzIG9uZSBjaHVuayBwZXIgY2FsbCBzbyB0aGUgZXhwb3J0IGRyaXZlciBjYW4gd3JpdGUgZWFjaCBwYWdlIHN0cmFpZ2h0IHRvIHRoZVxuICogZmlsZSBzaW5rIHdpdGhvdXQgaG9sZGluZyB0aGUgd2hvbGUgZG9jdW1lbnQgaW4gbWVtb3J5LiBSRkMtNDE4MCBxdW90aW5nLCBDUkxGIGxpbmUgYnJlYWtzLCBhbmQgYSBVVEYtOCBCT01cbiAqIHNvIEV4Y2VsIG9wZW5zIGl0IHdpdGggdGhlIHJpZ2h0IGVuY29kaW5nLlxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBBcGlNYWtlclRhYmxlRXhwb3J0Q3N2V3JpdGVyIHtcbiAgLyoqXG4gICAqIEBwYXJhbSB7QXJyYXk8c3RyaW5nPn0gbGFiZWxzXG4gICAqIEByZXR1cm5zIHtzdHJpbmd9XG4gICAqL1xuICBoZWFkZXIobGFiZWxzKSB7XG4gICAgcmV0dXJuIFVURjhfQk9NICsgdGhpcy5saW5lKGxhYmVscylcbiAgfVxuXG4gIC8qKlxuICAgKiBAcGFyYW0ge0FycmF5PHVua25vd24+fSB2YWx1ZXNcbiAgICogQHJldHVybnMge3N0cmluZ31cbiAgICovXG4gIHJvdyh2YWx1ZXMpIHtcbiAgICByZXR1cm4gdGhpcy5saW5lKHZhbHVlcylcbiAgfVxuXG4gIC8qKiBAcmV0dXJucyB7c3RyaW5nfSAqL1xuICBmb290ZXIoKSB7XG4gICAgcmV0dXJuIFwiXCJcbiAgfVxuXG4gIC8qKlxuICAgKiBAcGFyYW0ge0FycmF5PHVua25vd24+fSB2YWx1ZXNcbiAgICogQHJldHVybnMge3N0cmluZ31cbiAgICovXG4gIGxpbmUodmFsdWVzKSB7XG4gICAgcmV0dXJuIGAke3ZhbHVlcy5tYXAoKHZhbHVlKSA9PiB0aGlzLmVzY2FwZSh2YWx1ZSkpLmpvaW4oXCIsXCIpfVxcclxcbmBcbiAgfVxuXG4gIC8qKlxuICAgKiBAcGFyYW0ge3Vua25vd259IHZhbHVlXG4gICAqIEByZXR1cm5zIHtzdHJpbmd9XG4gICAqL1xuICBlc2NhcGUodmFsdWUpIHtcbiAgICBjb25zdCB0ZXh0ID0gY2VsbFRvVGV4dCh2YWx1ZSlcblxuICAgIGlmICgoL1tcIlxcclxcbixdLykudGVzdCh0ZXh0KSkge1xuICAgICAgcmV0dXJuIGBcIiR7dGV4dC5yZXBsYWNlKC9cIi9nLCBcIlxcXCJcXFwiXCIpfVwiYFxuICAgIH1cblxuICAgIHJldHVybiB0ZXh0XG4gIH1cbn1cbiJdfQ==

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"}