@kaspernj/api-maker 1.0.2170 → 1.0.2172

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,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

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/large-per-page-warning-modal.d.ts

@@ -0,0 +1,14 @@
+declare const _default: React.NamedExoticComponent<Record<string, any>>;
+export default _default;
+/**
+ * Confirmation shown when a user tries to load more rows than the configured dangerous threshold (e.g. the
+ * "All" per-page option on a very large collection). Warns that the load may freeze the browser, advises
+ * filtering, points to the existing Download export, and lets the user proceed or cancel.
+ */
+export type Props = {
+    count: number;
+    onConfirm: () => void;
+    onRequestClose: () => void;
+};
+import React from "react";
+//# sourceMappingURL=large-per-page-warning-modal.d.ts.map

package/build/table/large-per-page-warning-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"large-per-page-warning-modal.d.ts","sourceRoot":"/src/","sources":["table/large-per-page-warning-modal.jsx"],"names":[],"mappings":";;;;;;;;WAmBc,MAAM;eACN,MAAM,IAAI;oBACV,MAAM,IAAI;;kBAbN,OAAO"}

package/build/table/large-per-page-warning-modal.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
+/* eslint-disable sort-imports, react/jsx-max-depth */
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
+import apiMakerConfig from "../config.js";
+import Button from "../utils/button";
+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 Text from "../utils/text";
+import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
+import { View } from "react-native";
+/**
+ * Confirmation shown when a user tries to load more rows than the configured dangerous threshold (e.g. the
+ * "All" per-page option on a very large collection). Warns that the load may freeze the browser, advises
+ * filtering, points to the existing Download export, and lets the user proceed or cancel.
+ *
+ * @typedef {object} Props
+ * @property {number} count
+ * @property {() => void} onConfirm
+ * @property {() => void} onRequestClose
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props>} */ class ApiMakerTableLargePerPageWarningModal extends ShapeComponent {
+    static propTypes = propTypesExact({
+        count: PropTypes.number,
+        onConfirm: PropTypes.func.isRequired,
+        onRequestClose: PropTypes.func.isRequired
+    });
+    setup() {
+        const { t } = useI18n({ namespace: "js.api_maker.table.large_per_page_warning_modal" });
+        this.t = t;
+    }
+    render() {
+        const { count, onConfirm, onRequestClose, ...restProps } = this.p;
+        const Modal = apiMakerConfig.getModal();
+        const warningDefault = "You're about to load %{count} rows. " +
+            "This can make the page very slow or even crash your browser.";
+        const exportDefault = "To save the data as a file, open the table settings (the gear icon) and click " +
+            "Download — it saves the rows currently shown.";
+        return (_jsx(Modal, { onRequestClose: onRequestClose, ...restProps, children: _jsxs(View, { dataSet: this.cache("rootViewDataSet", { class: "large-per-page-warning-modal" }), style: this.cache("rootViewStyle", { padding: 20 }), testID: "large-per-page-warning-modal", children: [_jsx(Text, { style: this.cache("titleStyle", { fontSize: 18, fontWeight: "bold", marginBottom: 12 }), children: this.t(".title", { defaultValue: "Load a large number of rows?" }) }), _jsx(Text, { style: this.cache("warningStyle", { marginBottom: 8 }), children: this.t(".warning", { count, defaultValue: warningDefault }) }), _jsx(Text, { style: this.cache("filterAdviceStyle", { marginBottom: 8 }), children: this.t(".filter_advice", { defaultValue: "Consider narrowing your results with filters first." }) }), _jsx(Text, { style: this.cache("exportAdviceStyle", { marginBottom: 16 }), children: this.t(".export_advice", { defaultValue: exportDefault }) }), _jsxs(View, { style: this.cache("buttonsViewStyle", { flexDirection: "row", justifyContent: "flex-end" }), children: [_jsx(Button, { label: this.t(".cancel", { defaultValue: "Cancel" }), onPress: onRequestClose, pressableProps: this.cache("cancelButtonProps", { testID: "large-per-page-cancel-button" }) }), _jsx(View, { style: this.cache("buttonSpacerStyle", { width: 10 }) }), _jsx(Button, { danger: true, label: this.t(".proceed_anyway", { defaultValue: "Proceed anyway" }), onPress: onConfirm, pressableProps: this.cache("proceedButtonProps", { testID: "large-per-page-proceed-button" }) })] })] }) }));
+    }
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"large-per-page-warning-modal.js","sourceRoot":"/src/","sources":["table/large-per-page-warning-modal.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports, react/jsx-max-depth */\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport apiMakerConfig from \"../config.js\"\nimport Button from \"../utils/button\"\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\"\nimport {View} from \"react-native\"\n\n/**\n * Confirmation shown when a user tries to load more rows than the configured dangerous threshold (e.g. the\n * \"All\" per-page option on a very large collection). Warns that the load may freeze the browser, advises\n * filtering, points to the existing Download export, and lets the user proceed or cancel.\n *\n * @typedef {object} Props\n * @property {number} count\n * @property {() => void} onConfirm\n * @property {() => void} onRequestClose\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props>} */ class ApiMakerTableLargePerPageWarningModal extends ShapeComponent {\n  static propTypes = propTypesExact({\n    count: PropTypes.number,\n    onConfirm: PropTypes.func.isRequired,\n    onRequestClose: PropTypes.func.isRequired\n  })\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.large_per_page_warning_modal\"})\n\n    this.t = t\n  }\n\n  render() {\n    const {count, onConfirm, onRequestClose, ...restProps} = this.p\n    const Modal = apiMakerConfig.getModal()\n    const warningDefault = \"You're about to load %{count} rows. \" +\n      \"This can make the page very slow or even crash your browser.\"\n    const exportDefault = \"To save the data as a file, open the table settings (the gear icon) and click \" +\n      \"Download — it saves the rows currently shown.\"\n\n    return (\n      <Modal onRequestClose={onRequestClose} {...restProps}>\n        <View\n          dataSet={this.cache(\"rootViewDataSet\", {class: \"large-per-page-warning-modal\"})}\n          style={this.cache(\"rootViewStyle\", {padding: 20})}\n          testID=\"large-per-page-warning-modal\"\n        >\n          <Text style={this.cache(\"titleStyle\", {fontSize: 18, fontWeight: \"bold\", marginBottom: 12})}>\n            {this.t(\".title\", {defaultValue: \"Load a large number of rows?\"})}\n          </Text>\n          <Text style={this.cache(\"warningStyle\", {marginBottom: 8})}>\n            {this.t(\".warning\", {count, defaultValue: warningDefault})}\n          </Text>\n          <Text style={this.cache(\"filterAdviceStyle\", {marginBottom: 8})}>\n            {this.t(\".filter_advice\", {defaultValue: \"Consider narrowing your results with filters first.\"})}\n          </Text>\n          <Text style={this.cache(\"exportAdviceStyle\", {marginBottom: 16})}>\n            {this.t(\".export_advice\", {defaultValue: exportDefault})}\n          </Text>\n          <View style={this.cache(\"buttonsViewStyle\", {flexDirection: \"row\", justifyContent: \"flex-end\"})}>\n            <Button\n              label={this.t(\".cancel\", {defaultValue: \"Cancel\"})}\n              onPress={onRequestClose}\n              pressableProps={this.cache(\"cancelButtonProps\", {testID: \"large-per-page-cancel-button\"})}\n            />\n            <View style={this.cache(\"buttonSpacerStyle\", {width: 10})} />\n            <Button\n              danger\n              label={this.t(\".proceed_anyway\", {defaultValue: \"Proceed anyway\"})}\n              onPress={onConfirm}\n              pressableProps={this.cache(\"proceedButtonProps\", {testID: \"large-per-page-proceed-button\"})}\n            />\n          </View>\n        </View>\n      </Modal>\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/build/table/table.d.ts

@@ -85,7 +85,7 @@ export type BaseModel = {
     markForDestruction(): void;
     markedForDestruction(): boolean;
     uniqueKey(): number;
-    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("../command-execution").default;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("../command-execution.js").default;
     readAttribute(attributeName: string): ModelValue | null | undefined;
     readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
     isAttributeLoaded(attributeName: string): boolean;