@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/table/filters/save-search-modal.d.ts

@@ -1,4 +1,138 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type BaseModel = {
+    abilities: import("../../base-model.js").ModelAbilityMap;
+    changes: import("../../base-model.js").ModelDataMap;
+    collection: import("../../collection").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("../../base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("../../base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("../../base-model.js").LoadedRelationshipMap;
+    relationships: import("../../base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("../../command-execution").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("../../collection").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("../../collection").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("../../collection").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+};
+export type CurrentUserModel = BaseModel & {
+    id(): number | string;
+    modelClassData(): {
+        className: string;
+    };
+};
+export type TableSearchModel = BaseModel & {
+    isNewRecord(): boolean;
+    name(): string;
+    public(): boolean;
+    saveRaw(data: SearchFormData): Promise<void>;
+};
+export type SearchFormData = {
+    table_search: {
+        name?: string;
+        public?: boolean | string | number;
+        query_params?: string;
+        user_id?: number | string;
+        user_type?: string;
+    };
+};
+export type SearchForm = {
+    asObject(): SearchFormData;
+};
+export type Props = {
+    currentFilters: () => object[];
+    currentUser: CurrentUserModel;
+    onRequestClose: () => void;
+    search: TableSearchModel;
+};
+export type State = {
+    form: SearchForm | null;
+};
 import React from "react";
 //# sourceMappingURL=save-search-modal.d.ts.map

package/build/table/filters/save-search-modal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"save-search-modal.d.ts","sourceRoot":"/src/","sources":["table/filters/save-search-modal.jsx"],"names":[],"mappings":";;kBAQkB,OAAO"}
+{"version":3,"file":"save-search-modal.d.ts","sourceRoot":"/src/","sources":["table/filters/save-search-modal.jsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6Gs7yB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA5Fhh5B,SAAS,GAAG;IAAC,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC;IAAC,cAAc,IAAI;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC;+BAE3E,SAAS,GAAG;IACpB,WAAW,IAAI,OAAO,CAAC;IACvB,IAAI,IAAI,MAAM,CAAC;IACf,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7C;6BAGS;IAAC,YAAY,EAAE;QACvB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;QACnC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,CAAA;CAAC;yBAES;IAAC,QAAQ,IAAI,cAAc,CAAA;CAAC;;oBAG5B,MAAM,MAAM,EAAE;iBACd,gBAAgB;oBAChB,MAAM,IAAI;YACV,gBAAgB;;;UAIhB,UAAU,GAAG,IAAI;;kBArCb,OAAO"}

package/build/table/filters/save-search-modal.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable react/button-has-type, sort-imports */
-import BaseComponent from "../../base-component";
 import Checkbox from "../../bootstrap/checkbox";
 import { digg } from "diggerize";
 import { FlashNotifications } from "flash-notifications";
@@ -8,12 +8,43 @@ import { Form } from "../../form";
 import Input from "../../bootstrap/input";
 import modelClassRequire from "../../model-class-require.js";
 import React from "react";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import memo from "set-state-compare/build/memo.js";
 import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
 import apiMakerConfig from "../../config.js";
 const TableSearch = modelClassRequire("TableSearch");
-export default memo(shapeComponent(class ApiMakerTableFiltersSaveSearchModal extends BaseComponent {
+/** @typedef {import("../../base-model.js").default} BaseModel */
+/** @typedef {BaseModel & {id(): number | string, modelClassData(): {className: string}}} CurrentUserModel */
+/**
+ * @typedef {BaseModel & {
+ *   isNewRecord(): boolean,
+ *   name(): string,
+ *   public(): boolean,
+ *   saveRaw(data: SearchFormData): Promise<void>
+ * }} TableSearchModel
+ */
+/**
+ * @typedef {{table_search: {
+ *   name?: string,
+ *   public?: boolean | string | number,
+ *   query_params?: string,
+ *   user_id?: number | string,
+ *   user_type?: string
+ * }}} SearchFormData
+ */
+/** @typedef {{asObject(): SearchFormData}} SearchForm */
+/**
+ * @typedef {object} Props
+ * @property {() => object[]} currentFilters
+ * @property {CurrentUserModel} currentUser
+ * @property {() => void} onRequestClose
+ * @property {TableSearchModel} search
+ */
+/**
+ * @typedef {object} State
+ * @property {SearchForm | null} form
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFiltersSaveSearchModal extends ShapeComponent {
     state = {
         form: null
     };
@@ -24,7 +55,7 @@ export default memo(shapeComponent(class ApiMakerTableFiltersSaveSearchModal ext
     render() {
         const { currentFilters, currentUser, onRequestClose, search, ...restProps } = this.props;
         const Modal = apiMakerConfig.getModal();
-        return (_jsx(Modal, { onRequestClose: onRequestClose, ...restProps, children: _jsxs(Form, { onSubmit: this.tt.onSaveSearchSubmit, setForm: /** @type {Record<string, any>} */ (this.setStates).form, useHtmlForm: true, children: [_jsx(Input, { defaultValue: search.name(), id: "table_search_name", label: this.t(".search_name", { defaultValue: "Search name" }), name: "table_search[name]" }), _jsx(Checkbox, { defaultChecked: search.public(), id: "table_search_public", label: this.t(".public", { defaultValue: "Public" }), name: "table_search[public]" }), _jsx("button", { className: "save-search-submit-button", children: this.t(".save_search", { defaultValue: "Save search" }) })] }) }));
+        return (_jsx(Modal, { onRequestClose: onRequestClose, ...restProps, children: _jsxs(Form, { onSubmit: this.tt.onSaveSearchSubmit, setForm: /** @type {(form: SearchForm | null) => void} */ (this.setStates.form), useHtmlForm: true, children: [_jsx(Input, { defaultValue: search.name(), id: "table_search_name", label: this.t(".search_name", { defaultValue: "Search name" }), name: "table_search[name]" }), _jsx(Checkbox, { defaultChecked: search.public(), id: "table_search_public", label: this.t(".public", { defaultValue: "Public" }), name: "table_search[public]" }), _jsx("button", { className: "save-search-submit-button", children: this.t(".save_search", { defaultValue: "Save search" }) })] }) }));
     }
     onSaveSearchSubmit = async () => {
         const formData = this.s.form.asObject();
@@ -47,4 +78,4 @@ export default memo(shapeComponent(class ApiMakerTableFiltersSaveSearchModal ext
         }
     };
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save-search-modal.js","sourceRoot":"/src/","sources":["table/filters/save-search-modal.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable react/button-has-type, sort-imports */\nimport Checkbox from \"../../bootstrap/checkbox\"\nimport {digg} from \"diggerize\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport {Form} from \"../../form\"\nimport Input from \"../../bootstrap/input\"\nimport modelClassRequire from \"../../model-class-require.js\"\nimport React from \"react\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport apiMakerConfig from \"../../config.js\"\n\nconst TableSearch = modelClassRequire(\"TableSearch\")\n\n/** @typedef {import(\"../../base-model.js\").default} BaseModel */\n/** @typedef {BaseModel & {id(): number | string, modelClassData(): {className: string}}} CurrentUserModel */\n/**\n * @typedef {BaseModel & {\n *   isNewRecord(): boolean,\n *   name(): string,\n *   public(): boolean,\n *   saveRaw(data: SearchFormData): Promise<void>\n * }} TableSearchModel\n */\n/**\n * @typedef {{table_search: {\n *   name?: string,\n *   public?: boolean | string | number,\n *   query_params?: string,\n *   user_id?: number | string,\n *   user_type?: string\n * }}} SearchFormData\n */\n/** @typedef {{asObject(): SearchFormData}} SearchForm */\n/**\n * @typedef {object} Props\n * @property {() => object[]} currentFilters\n * @property {CurrentUserModel} currentUser\n * @property {() => void} onRequestClose\n * @property {TableSearchModel} search\n */\n/**\n * @typedef {object} State\n * @property {SearchForm | null} form\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFiltersSaveSearchModal extends ShapeComponent {\n  state = {\n    form: null\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters.save_search_modal\"})\n\n    this.t = t\n  }\n\n  render() {\n    const {currentFilters, currentUser, onRequestClose, search, ...restProps} = this.props\n    const Modal = apiMakerConfig.getModal()\n\n    return (\n      <Modal onRequestClose={onRequestClose} {...restProps}>\n        <Form onSubmit={this.tt.onSaveSearchSubmit} setForm={/** @type {(form: SearchForm | null) => void} */ (this.setStates.form)} useHtmlForm>\n          <Input\n            defaultValue={search.name()}\n            id=\"table_search_name\"\n            label={this.t(\".search_name\", {defaultValue: \"Search name\"})}\n            name=\"table_search[name]\"\n          />\n          <Checkbox\n            defaultChecked={search.public()}\n            id=\"table_search_public\"\n            label={this.t(\".public\", {defaultValue: \"Public\"})}\n            name=\"table_search[public]\"\n          />\n          <button className=\"save-search-submit-button\">\n            {this.t(\".save_search\", {defaultValue: \"Save search\"})}\n          </button>\n        </Form>\n      </Modal>\n    )\n  }\n\n  onSaveSearchSubmit = async () => {\n    const formData = this.s.form.asObject()\n    const {currentFilters, currentUser, onRequestClose, search} = this.p\n    const hasUserTypeColumn = Boolean(TableSearch.attributes().find((attribute) => attribute.name() == \"user_type\"))\n\n    if (search.isNewRecord()) {\n      formData.table_search.query_params = JSON.stringify(currentFilters())\n    }\n\n    if (hasUserTypeColumn) {\n      formData.table_search.user_type = digg(currentUser.modelClassData(), \"className\")\n    }\n\n    formData.table_search.user_id = currentUser.id()\n\n    try {\n      await search.saveRaw(formData)\n      FlashNotifications.success(this.t(\".\", {defaultValue: \"The search was saved.\"}))\n      onRequestClose()\n    } catch (error) {\n      FlashNotifications.errorResponse(error)\n    }\n  }\n}))\n"]}

package/build/table/filters/scope-element.d.ts

@@ -1,4 +1,10 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = {
+    active?: boolean;
+    onScopeClicked: Function;
+    scope: string;
+};
+export type State = Record<string, never>;
 import React from "react";
 //# sourceMappingURL=scope-element.d.ts.map

package/build/table/filters/scope-element.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scope-element.d.ts","sourceRoot":"/src/","sources":["table/filters/scope-element.jsx"],"names":[],"mappings":";;kBAKkB,OAAO"}
+{"version":3,"file":"scope-element.d.ts","sourceRoot":"/src/","sources":["table/filters/scope-element.jsx"],"names":[],"mappings":";;;aAac,OAAO;;WAEP,MAAM;;oBAEN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBAZjB,OAAO"}

package/build/table/filters/scope-element.js

@@ -1,27 +1,32 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable no-return-assign, sort-imports */
-import BaseComponent from "../../base-component";
 import PropTypes from "prop-types";
 import memo from "set-state-compare/build/memo.js";
 import { Pressable } from "react-native";
 import React from "react";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import Text from "../../utils/text";
 const dataSets = {};
-export default memo(shapeComponent(class ScopeElement extends BaseComponent {
+/**
+ * @typedef {object} Props
+ * @property {boolean} [active]
+ * @property {Function} onScopeClicked
+ * @property {string} scope
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ScopeElement extends ShapeComponent {
     static defaultProps = {
         active: false
     };
     static propTypes = {
-        active: PropTypes.bool.isRequired,
+        active: PropTypes.bool,
         onScopeClicked: PropTypes.func.isRequired,
         scope: PropTypes.string.isRequired
     };
     render() {
         const { active, scope } = this.p;
-        const style = {};
-        if (active)
-            style.fontWeight = "bold";
+        const style = active ? /** @type {import("react-native").TextStyle} */ ({ fontWeight: "bold" }) : undefined;
         return (_jsx(Pressable, { dataSet: dataSets[`scope-${scope}`] ||= { class: "scope-element", scopeName: scope }, onPress: this.tt.onScopeClicked, children: _jsx(Text, { style: style, children: scope }) }, scope));
     }
     onScopeClicked = (e) => {
@@ -29,4 +34,4 @@ export default memo(shapeComponent(class ScopeElement extends BaseComponent {
         this.p.onScopeClicked({ scope: this.p.scope });
     };
 }));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NvcGUtZWxlbWVudC5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidGFibGUvZmlsdGVycy9zY29wZS1lbGVtZW50LmpzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsbURBQW1EO0FBQ25ELE9BQU8sYUFBYSxNQUFNLHNCQUFzQixDQUFBO0FBQ2hELE9BQU8sU0FBUyxNQUFNLFlBQVksQ0FBQTtBQUNsQyxPQUFPLElBQUksTUFBTSxpQ0FBaUMsQ0FBQTtBQUNsRCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0sY0FBYyxDQUFBO0FBQ3RDLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQTtBQUN6QixPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sNENBQTRDLENBQUE7QUFDekUsT0FBTyxJQUFJLE1BQU0sa0JBQWtCLENBQUE7QUFFbkMsTUFBTSxRQUFRLEdBQUcsRUFBRSxDQUFBO0FBRW5CLGVBQWUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLFlBQWEsU0FBUSxhQUFhO0lBQ3pFLE1BQU0sQ0FBQyxZQUFZLEdBQUc7UUFDcEIsTUFBTSxFQUFFLEtBQUs7S0FDZCxDQUFBO0lBRUQsTUFBTSxDQUFDLFNBQVMsR0FBRztRQUNqQixNQUFNLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxVQUFVO1FBQ2pDLGNBQWMsRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLFVBQVU7UUFDekMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxNQUFNLENBQUMsVUFBVTtLQUNuQyxDQUFBO0lBRUQsTUFBTTtRQUNKLE1BQU0sRUFBQyxNQUFNLEVBQUUsS0FBSyxFQUFDLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQTtRQUM5QixNQUFNLEtBQUssR0FBRyxFQUFFLENBQUE7UUFFaEIsSUFBSSxNQUFNO1lBQUUsS0FBSyxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUE7UUFFckMsT0FBTyxDQUNMLEtBQUMsU0FBUyxJQUNSLE9BQU8sRUFBRSxRQUFRLENBQUMsU0FBUyxLQUFLLEVBQUUsQ0FBQyxLQUFLLEVBQUMsS0FBSyxFQUFFLGVBQWUsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFDLEVBRWxGLE9BQU8sRUFBRSxJQUFJLENBQUMsRUFBRSxDQUFDLGNBQWMsWUFFL0IsS0FBQyxJQUFJLElBQUMsS0FBSyxFQUFFLEtBQUssWUFDZixLQUFLLEdBQ0QsSUFMRixLQUFLLENBTUEsQ0FDYixDQUFBO0lBQ0gsQ0FBQztJQUVELGNBQWMsR0FBRyxDQUFDLENBQUMsRUFBRSxFQUFFO1FBQ3JCLENBQUMsQ0FBQyxjQUFjLEVBQUUsQ0FBQTtRQUVsQixJQUFJLENBQUMsQ0FBQyxDQUFDLGNBQWMsQ0FBQyxFQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBQyxDQUFDLENBQUE7SUFDOUMsQ0FBQyxDQUFBO0NBQ0YsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBuby1yZXR1cm4tYXNzaWduLCBzb3J0LWltcG9ydHMgKi9cbmltcG9ydCBCYXNlQ29tcG9uZW50IGZyb20gXCIuLi8uLi9iYXNlLWNvbXBvbmVudFwiXG5pbXBvcnQgUHJvcFR5cGVzIGZyb20gXCJwcm9wLXR5cGVzXCJcbmltcG9ydCBtZW1vIGZyb20gXCJzZXQtc3RhdGUtY29tcGFyZS9idWlsZC9tZW1vLmpzXCJcbmltcG9ydCB7UHJlc3NhYmxlfSBmcm9tIFwicmVhY3QtbmF0aXZlXCJcbmltcG9ydCBSZWFjdCBmcm9tIFwicmVhY3RcIlxuaW1wb3J0IHtzaGFwZUNvbXBvbmVudH0gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL2J1aWxkL3NoYXBlLWNvbXBvbmVudC5qc1wiXG5pbXBvcnQgVGV4dCBmcm9tIFwiLi4vLi4vdXRpbHMvdGV4dFwiXG5cbmNvbnN0IGRhdGFTZXRzID0ge31cblxuZXhwb3J0IGRlZmF1bHQgbWVtbyhzaGFwZUNvbXBvbmVudChjbGFzcyBTY29wZUVsZW1lbnQgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcbiAgc3RhdGljIGRlZmF1bHRQcm9wcyA9IHtcbiAgICBhY3RpdmU6IGZhbHNlXG4gIH1cblxuICBzdGF0aWMgcHJvcFR5cGVzID0ge1xuICAgIGFjdGl2ZTogUHJvcFR5cGVzLmJvb2wuaXNSZXF1aXJlZCxcbiAgICBvblNjb3BlQ2xpY2tlZDogUHJvcFR5cGVzLmZ1bmMuaXNSZXF1aXJlZCxcbiAgICBzY29wZTogUHJvcFR5cGVzLnN0cmluZy5pc1JlcXVpcmVkXG4gIH1cblxuICByZW5kZXIoKSB7XG4gICAgY29uc3Qge2FjdGl2ZSwgc2NvcGV9ID0gdGhpcy5wXG4gICAgY29uc3Qgc3R5bGUgPSB7fVxuXG4gICAgaWYgKGFjdGl2ZSkgc3R5bGUuZm9udFdlaWdodCA9IFwiYm9sZFwiXG5cbiAgICByZXR1cm4gKFxuICAgICAgPFByZXNzYWJsZVxuICAgICAgICBkYXRhU2V0PXtkYXRhU2V0c1tgc2NvcGUtJHtzY29wZX1gXSB8fD0ge2NsYXNzOiBcInNjb3BlLWVsZW1lbnRcIiwgc2NvcGVOYW1lOiBzY29wZX19XG4gICAgICAgIGtleT17c2NvcGV9XG4gICAgICAgIG9uUHJlc3M9e3RoaXMudHQub25TY29wZUNsaWNrZWR9XG4gICAgICA+XG4gICAgICAgIDxUZXh0IHN0eWxlPXtzdHlsZX0+XG4gICAgICAgICAge3Njb3BlfVxuICAgICAgICA8L1RleHQ+XG4gICAgICA8L1ByZXNzYWJsZT5cbiAgICApXG4gIH1cblxuICBvblNjb3BlQ2xpY2tlZCA9IChlKSA9PiB7XG4gICAgZS5wcmV2ZW50RGVmYXVsdCgpXG5cbiAgICB0aGlzLnAub25TY29wZUNsaWNrZWQoe3Njb3BlOiB0aGlzLnAuc2NvcGV9KVxuICB9XG59KSlcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/header-column-content.d.ts

@@ -1,4 +1,11 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = {
+    column: object;
+    sortLinkProps?: object;
+    table: object;
+    tableSettingColumn: object;
+};
+export type State = Record<string, never>;
 import React from "react";
 //# sourceMappingURL=header-column-content.d.ts.map

package/build/table/header-column-content.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header-column-content.d.ts","sourceRoot":"/src/","sources":["table/header-column-content.jsx"],"names":[],"mappings":";;kBAOkB,OAAO"}
+{"version":3,"file":"header-column-content.d.ts","sourceRoot":"/src/","sources":["table/header-column-content.jsx"],"names":[],"mappings":";;;YAcc,MAAM;oBACN,MAAM;WACN,MAAM;wBACN,MAAM;;oBAEN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBAZjB,OAAO"}

package/build/table/header-column-content.js

@@ -1,16 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
-import BaseComponent from "../base-component";
 import { digs } from "diggerize";
 import memo from "set-state-compare/build/memo.js";
 import { View } from "react-native";
 import PropTypes from "prop-types";
 import propTypesExact from "prop-types-exact";
 import React from "react";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import SortLink from "../bootstrap/sort-link";
 import Text from "../utils/text";
-export default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseComponent {
+/**
+ * @typedef {object} Props
+ * @property {object} column
+ * @property {object} [sortLinkProps]
+ * @property {object} table
+ * @property {object} tableSettingColumn
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableHeaderColumn extends ShapeComponent {
     static propTypes = propTypesExact({
         column: PropTypes.object.isRequired,
         sortLinkProps: PropTypes.object,
@@ -44,4 +52,4 @@ export default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseC
                     _jsx(Text, { ellipsizeMode: "clip", numberOfLines: 1, style: this.cache("headerLabelStyle", { flexShrink: 1, fontWeight: "bold" }), children: table.headerLabelForColumn(column) })] }));
     }
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/header-column.d.ts

@@ -1,4 +1,54 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type DataSetLike = {
+    className?: string;
+};
+export type TableColumnDefinition = {
+    attribute?: string;
+};
+export type TableSettingColumn = {
+    identifier(): string;
+    sortKey(): string;
+    update(args: {
+        width: number;
+    }): Promise<void>;
+};
+export type HeaderTableLike = {
+    headerClassNameForColumn: (column: TableColumnDefinition) => string[];
+    headerProps: (column: TableColumnDefinition) => {
+        style?: object;
+    };
+    setState: (args: object) => void;
+    tt: {
+        styleForHeader(args: {
+            style: object;
+        }): object;
+    };
+};
+export type ResizeHandleStyle = {
+    cursor?: "col-resize";
+    height?: "100%";
+    position: "absolute";
+    right: number;
+    top: number;
+    width: number;
+    zIndex: number;
+};
+export type Props = {
+    active: boolean;
+    animatedWidth: Animated.Value;
+    animatedZIndex: Animated.Value;
+    column: TableColumnDefinition;
+    resizing: boolean;
+    table: HeaderTableLike;
+    tableSettingColumn: TableSettingColumn;
+    touchProps: DataSetLike;
+    widths: Widths;
+};
+export type State = {
+    resizing: boolean;
+};
 import React from "react";
+import { Animated } from "react-native";
+import Widths from "./widths";
 //# sourceMappingURL=header-column.d.ts.map

package/build/table/header-column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header-column.d.ts","sourceRoot":"/src/","sources":["table/header-column.jsx"],"names":[],"mappings":";;kBAC6B,OAAO"}
+{"version":3,"file":"header-column.d.ts","sourceRoot":"/src/","sources":["table/header-column.jsx"],"names":[],"mappings":";;0BAiBc;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC;oCACpB;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC;iCACpB;IAAC,UAAU,IAAI,MAAM,CAAC;IAAC,OAAO,IAAI,MAAM,CAAC;IAAC,MAAM,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC;;8BAGvF,CAAC,MAAM,EAAE,qBAAqB,KAAK,MAAM,EAAE;iBAC3C,CAAC,MAAM,EAAE,qBAAqB,KAAK;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC;cACnD,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;QACtB;QAAC,cAAc,CAAC,IAAI,EAAE;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,GAAG,MAAM,CAAA;KAAC;;gCAE/C;IAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC;;YAIzH,OAAO;mBACP,QAAQ,CAAC,KAAK;oBACd,QAAQ,CAAC,KAAK;YACd,qBAAqB;cACrB,OAAO;WACP,eAAe;wBACf,kBAAkB;gBAClB,WAAW;YACX,MAAM;;;cAIN,OAAO;;kBAzCQ,OAAO;yBAMC,cAAc;mBAKhC,UAAU"}

package/build/table/header-column.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable import/no-unresolved, no-return-assign, sort-imports */
 import React, { useMemo } from "react";
-import BaseComponent from "../base-component";
 import classNames from "classnames";
 import Header from "./components/header";
 import HeaderColumnContent from "./header-column-content";
@@ -10,11 +10,38 @@ import memo from "set-state-compare/build/memo.js";
 import { Animated, PanResponder } from "react-native";
 import PropTypes from "prop-types";
 import propTypesExact from "prop-types-exact";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import { useBreakpoint } from "responsive-breakpoints";
 import Widths from "./widths";
 const dataSets = {};
-export default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseComponent {
+/** @typedef {{className?: string}} DataSetLike */
+/** @typedef {{attribute?: string}} TableColumnDefinition */
+/** @typedef {{identifier(): string, sortKey(): string, update(args: {width: number}): Promise<void>}} TableSettingColumn */
+/**
+ * @typedef {object} HeaderTableLike
+ * @property {(column: TableColumnDefinition) => string[]} headerClassNameForColumn
+ * @property {(column: TableColumnDefinition) => {style?: object}} headerProps
+ * @property {(args: object) => void} setState
+ * @property {{styleForHeader(args: {style: object}): object}} tt
+ */
+/** @typedef {{cursor?: "col-resize", height?: "100%", position: "absolute", right: number, top: number, width: number, zIndex: number}} ResizeHandleStyle */
+/**
+ * @typedef {object} Props
+ * @property {boolean} active
+ * @property {Animated.Value} animatedWidth
+ * @property {Animated.Value} animatedZIndex
+ * @property {TableColumnDefinition} column
+ * @property {boolean} resizing
+ * @property {HeaderTableLike} table
+ * @property {TableSettingColumn} tableSettingColumn
+ * @property {DataSetLike} touchProps
+ * @property {Widths} widths
+ */
+/**
+ * @typedef {object} State
+ * @property {boolean} resizing
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableHeaderColumn extends ShapeComponent {
     static propTypes = propTypesExact({
         active: PropTypes.bool.isRequired,
         animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,
@@ -80,7 +107,7 @@ export default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseC
                 identifier: headerIdentifier
             }, onLayout: this.tt.onLayout, style: styleForHeader({ style: actualStyle }), ...restColumnProps, children: [mdUp &&
                     _jsx(Icon, { name: "bars", style: this.cache("barsIconStyle", { marginRight: 3, fontSize: 12 }), ...touchProps }), _jsx(HeaderColumnContent, { column: column, table: table, tableSettingColumn: tableSettingColumn }), mdUp &&
-                    _jsx(Animated.View, { style: /** @type {any} */ (this.cache("resizeColumnViewStyle", {
+                    _jsx(Animated.View, { style: /** @type {object} */ (this.cache("resizeColumnViewStyle", {
                             position: "absolute",
                             top: 0,
                             right: 0,
@@ -95,4 +122,4 @@ export default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseC
         this.currentWidth = width;
     };
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-column.js","sourceRoot":"/src/","sources":["table/header-column.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-unresolved, no-return-assign, sort-imports */\nimport React, {useMemo} from \"react\"\nimport BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport Header from \"./components/header\"\nimport HeaderColumnContent from \"./header-column-content\"\nimport Icon from \"../utils/icon\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {Animated, PanResponder} from \"react-native\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport {useBreakpoint} from \"responsive-breakpoints\"\nimport Widths from \"./widths\"\n\nconst dataSets = {}\n\nexport default memo(shapeComponent(class ApiMakerTableHeaderColumn extends BaseComponent {\n  static propTypes = propTypesExact({\n    active: PropTypes.bool.isRequired,\n    animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,\n    animatedZIndex: PropTypes.instanceOf(Animated.Value).isRequired,\n    column: PropTypes.object.isRequired,\n    resizing: PropTypes.bool.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingColumn: PropTypes.object.isRequired,\n    touchProps: PropTypes.object.isRequired,\n    widths: PropTypes.instanceOf(Widths).isRequired\n  })\n\n  state = {\n    resizing: false\n  }\n\n  setup() {\n    const {name: breakpoint, mdUp, smDown} = useBreakpoint()\n\n    this.breakpoint = breakpoint\n    this.mdUp = mdUp\n    this.smDown = smDown\n\n    this.resizePanResponder = useMemo(\n      () => PanResponder.create({\n        onStartShouldSetPanResponder: (_e) => {\n          this.originalWidth = this.currentWidth\n          this.setState({resizing: true})\n          this.p.table.setState({resizing: true})\n\n          return true\n        },\n        onPanResponderMove: (_e, gestate) => {\n          const newWidth = this.tt.originalWidth + gestate.dx\n\n          this.p.widths.setWidthOfColumn({\n            identifier: this.p.tableSettingColumn.identifier(),\n            width: newWidth\n          })\n        },\n        onPanResponderRelease: this.tt.onResizeEnd,\n        onPanResponderTerminate: this.tt.onResizeEnd,\n        onPanResponderTerminationRequest: () => false // Don't let another PanResponder steal focus and stop resizing until release\n      }),\n      []\n    )\n  }\n\n  onResizeEnd = async () => {\n    this.p.table.setState({lastUpdate: new Date(), resizing: false})\n    this.setState({resizing: false})\n\n    const width = this.p.widths.getWidthOfColumn(this.p.tableSettingColumn.identifier())\n\n    await this.p.tableSettingColumn.update({width})\n  }\n\n  render() {\n    const {mdUp} = this.tt\n    const {active, animatedWidth, column, resizing, table, tableSettingColumn, touchProps} = this.p\n    const {styleForHeader} = table.tt\n    const headerProps = table.headerProps(column)\n    const {style, ...restColumnProps} = headerProps\n    const headerIdentifier = tableSettingColumn.identifier()\n    const actualStyle = useMemo(\n      () => {\n        // eslint-disable-next-line prefer-object-spread\n        const actualStyle = Object.assign(\n          {\n            cursor: resizing ? \"col-resize\" : undefined,\n            width: mdUp ? animatedWidth : \"100%\",\n            height: mdUp ? \"100%\" : undefined\n          },\n          style\n        )\n\n        return actualStyle\n      },\n      [active, animatedWidth, mdUp, resizing, style]\n    )\n\n    return (\n      <Header\n        dataSet={dataSets[`header-${headerIdentifier}`] ||= {\n          className: classNames(...table.headerClassNameForColumn(column)),\n          identifier: headerIdentifier\n        }}\n        onLayout={this.tt.onLayout}\n        style={styleForHeader({style: actualStyle})}\n        {...restColumnProps}\n      >\n        {mdUp &&\n          <Icon name=\"bars\" style={this.cache(\"barsIconStyle\", {marginRight: 3, fontSize: 12})} {...touchProps} />\n        }\n        <HeaderColumnContent column={column} table={table} tableSettingColumn={tableSettingColumn} />\n        {mdUp &&\n          <Animated.View\n            style={/** @type {any} */ (this.cache(\"resizeColumnViewStyle\", {\n              position: \"absolute\",\n              top: 0,\n              right: 0,\n              width: 10,\n              height: \"100%\",\n              cursor: \"col-resize\",\n              zIndex: 9999\n            }))}\n            {...this.tt.resizePanResponder.panHandlers}\n          />\n        }\n      </Header>\n    )\n  }\n\n  onLayout = (e) => {\n    const {width} = e.nativeEvent.layout\n\n    this.currentWidth = width\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-column.js","sourceRoot":"/src/","sources":["table/header-column.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable import/no-unresolved, no-return-assign, sort-imports */\nimport React, {useMemo} from \"react\"\nimport classNames from \"classnames\"\nimport Header from \"./components/header\"\nimport HeaderColumnContent from \"./header-column-content\"\nimport Icon from \"../utils/icon\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {Animated, PanResponder} from \"react-native\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport {useBreakpoint} from \"responsive-breakpoints\"\nimport Widths from \"./widths\"\n\nconst dataSets = {}\n\n/** @typedef {{className?: string}} DataSetLike */\n/** @typedef {{attribute?: string}} TableColumnDefinition */\n/** @typedef {{identifier(): string, sortKey(): string, update(args: {width: number}): Promise<void>}} TableSettingColumn */\n/**\n * @typedef {object} HeaderTableLike\n * @property {(column: TableColumnDefinition) => string[]} headerClassNameForColumn\n * @property {(column: TableColumnDefinition) => {style?: object}} headerProps\n * @property {(args: object) => void} setState\n * @property {{styleForHeader(args: {style: object}): object}} tt\n */\n/** @typedef {{cursor?: \"col-resize\", height?: \"100%\", position: \"absolute\", right: number, top: number, width: number, zIndex: number}} ResizeHandleStyle */\n\n/**\n * @typedef {object} Props\n * @property {boolean} active\n * @property {Animated.Value} animatedWidth\n * @property {Animated.Value} animatedZIndex\n * @property {TableColumnDefinition} column\n * @property {boolean} resizing\n * @property {HeaderTableLike} table\n * @property {TableSettingColumn} tableSettingColumn\n * @property {DataSetLike} touchProps\n * @property {Widths} widths\n */\n/**\n * @typedef {object} State\n * @property {boolean} resizing\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableHeaderColumn extends ShapeComponent {\n  static propTypes = propTypesExact({\n    active: PropTypes.bool.isRequired,\n    animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,\n    animatedZIndex: PropTypes.instanceOf(Animated.Value).isRequired,\n    column: PropTypes.object.isRequired,\n    resizing: PropTypes.bool.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingColumn: PropTypes.object.isRequired,\n    touchProps: PropTypes.object.isRequired,\n    widths: PropTypes.instanceOf(Widths).isRequired\n  })\n\n  state = {\n    resizing: false\n  }\n\n  setup() {\n    const {name: breakpoint, mdUp, smDown} = useBreakpoint()\n\n    this.breakpoint = breakpoint\n    this.mdUp = mdUp\n    this.smDown = smDown\n\n    this.resizePanResponder = useMemo(\n      () => PanResponder.create({\n        onStartShouldSetPanResponder: (_e) => {\n          this.originalWidth = this.currentWidth\n          this.setState({resizing: true})\n          this.p.table.setState({resizing: true})\n\n          return true\n        },\n        onPanResponderMove: (_e, gestate) => {\n          const newWidth = this.tt.originalWidth + gestate.dx\n\n          this.p.widths.setWidthOfColumn({\n            identifier: this.p.tableSettingColumn.identifier(),\n            width: newWidth\n          })\n        },\n        onPanResponderRelease: this.tt.onResizeEnd,\n        onPanResponderTerminate: this.tt.onResizeEnd,\n        onPanResponderTerminationRequest: () => false // Don't let another PanResponder steal focus and stop resizing until release\n      }),\n      []\n    )\n  }\n\n  onResizeEnd = async () => {\n    this.p.table.setState({lastUpdate: new Date(), resizing: false})\n    this.setState({resizing: false})\n\n    const width = this.p.widths.getWidthOfColumn(this.p.tableSettingColumn.identifier())\n\n    await this.p.tableSettingColumn.update({width})\n  }\n\n  render() {\n    const {mdUp} = this.tt\n    const {active, animatedWidth, column, resizing, table, tableSettingColumn, touchProps} = this.p\n    const {styleForHeader} = table.tt\n    const headerProps = table.headerProps(column)\n    const {style, ...restColumnProps} = headerProps\n    const headerIdentifier = tableSettingColumn.identifier()\n    const actualStyle = useMemo(\n      () => {\n        // eslint-disable-next-line prefer-object-spread\n        const actualStyle = Object.assign(\n          {\n            cursor: resizing ? \"col-resize\" : undefined,\n            width: mdUp ? animatedWidth : \"100%\",\n            height: mdUp ? \"100%\" : undefined\n          },\n          style\n        )\n\n        return actualStyle\n      },\n      [active, animatedWidth, mdUp, resizing, style]\n    )\n\n    return (\n      <Header\n        dataSet={dataSets[`header-${headerIdentifier}`] ||= {\n          className: classNames(...table.headerClassNameForColumn(column)),\n          identifier: headerIdentifier\n        }}\n        onLayout={this.tt.onLayout}\n        style={styleForHeader({style: actualStyle})}\n        {...restColumnProps}\n      >\n        {mdUp &&\n          <Icon name=\"bars\" style={this.cache(\"barsIconStyle\", {marginRight: 3, fontSize: 12})} {...touchProps} />\n        }\n        <HeaderColumnContent column={column} table={table} tableSettingColumn={tableSettingColumn} />\n        {mdUp &&\n          <Animated.View\n            style={/** @type {object} */ (this.cache(\"resizeColumnViewStyle\", {\n              position: \"absolute\",\n              top: 0,\n              right: 0,\n              width: 10,\n              height: \"100%\",\n              cursor: \"col-resize\",\n              zIndex: 9999\n            }))}\n            {...this.tt.resizePanResponder.panHandlers}\n          />\n        }\n      </Header>\n    )\n  }\n\n  onLayout = (e) => {\n    const {width} = e.nativeEvent.layout\n\n    this.currentWidth = width\n  }\n}))\n"]}

package/build/table/header-select.d.ts

@@ -1,4 +1,22 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type PreparedColumn = {
+    column: object;
+    tableSettingColumn: {
+        identifier(): string;
+        sortKey(): string;
+    };
+};
+export type Props = {
+    preparedColumns: PreparedColumn[];
+    query: Collection<any>;
+    table?: {
+        headerLabelForColumn(column: object): string;
+    };
+};
+export type State = {
+    modalOpen: boolean;
+};
 import React from "react";
+import Collection from "../collection.js";
 //# sourceMappingURL=header-select.d.ts.map

package/build/table/header-select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header-select.d.ts","sourceRoot":"/src/","sources":["table/header-select.jsx"],"names":[],"mappings":";;kBASkB,OAAO"}
+{"version":3,"file":"header-select.d.ts","sourceRoot":"/src/","sources":["table/header-select.jsx"],"names":[],"mappings":";;;YAiBc,MAAM;wBACN;QAAC,UAAU,IAAI,MAAM,CAAC;QAAC,OAAO,IAAI,MAAM,CAAA;KAAC;;;qBAKzC,cAAc,EAAE;;YAEhB;QAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC;;;eAI9C,OAAO;;kBApBH,OAAO;uBANF,kBAAkB"}