@kaspernj/api-maker 1.0.2160 → 1.0.2161

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

@@ -1,31 +1,36 @@
 export default class ApiMakerTableColumnContent {
     /**
      * @param {object} args
-     * @param {any} args.column
-     * @param {any} args.l
+     * @param {TableColumn} args.column
+     * @param {LocalizeDateTime} args.l
      * @param {string} [args.mode]
-     * @param {any} args.model
-     * @param {Function} [args.t]
-     * @param {any} args.table
+     * @param {ContentModel} args.model
+     * @param {TranslateFn} [args.t]
+     * @param {TableLike} args.table
      */
     constructor({ column, l, mode, model, t, table }: {
-        column: any;
-        l: any;
+        column: TableColumn;
+        l: LocalizeDateTime;
         mode?: string;
-        model: any;
-        t?: Function;
-        table: any;
+        model: ContentModel;
+        t?: TranslateFn;
+        table: TableLike;
     });
-    column: any;
-    l: any;
+    column: TableColumn;
+    l: LocalizeDateTime;
     mode: string;
-    model: any;
-    t: Function;
-    table: any;
-    columnContentFromContentArg(): any;
-    columnsContentFromAttributeAndPath(): any;
-    content(): any;
-    presentColumnValue: (value: any) => any;
+    model: ContentModel;
+    t: TranslateFn;
+    table: TableLike;
+    columnContentFromContentArg(): React.ReactNode;
+    /** @returns {React.ReactNode | undefined} */
+    columnsContentFromAttributeAndPath(): React.ReactNode | undefined;
+    content(): React.ReactNode;
+    /**
+     * @param {ColumnValue} value
+     * @returns {React.ReactNode}
+     */
+    presentColumnValue: (value: ColumnValue) => React.ReactNode;
     /**
      * Presents date and datetime values using either translation-format keys or formatter callbacks.
      * @param {object} args
@@ -51,4 +56,135 @@ export default class ApiMakerTableColumnContent {
         value: Date;
     }): string;
 }
+export type BaseModel = {
+    abilities: import("../base-model.js").ModelAbilityMap;
+    changes: import("../base-model.js").ModelDataMap;
+    collection: import("../collection.js").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.js").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.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("../collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("../collection.js").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 MoneyLike = import("../money-formatter.js").MoneyLike;
+export type AttributeDefinition = {
+    getColumn: () => import("../base-model/column.js").default | undefined;
+    name: () => string;
+};
+export type PrimitiveColumnValue = string | Date | boolean | number | null | undefined | React.ReactNode | MoneyLike;
+export type ColumnValue = PrimitiveColumnValue | PrimitiveColumnValue[];
+export type LocalizeDateTime = (format: string, value: Date) => string;
+export type TranslateFn = (key: string, args?: object) => string;
+export type TableColumn = {
+    attribute?: string;
+    content?: (args: Record<string, BaseModel | string>) => ColumnValue;
+    path?: string[];
+};
+export type TableProps = {
+    defaultDateFormatName?: string | ((args: object) => string);
+    defaultDateTimeFormatName?: string | ((args: object) => string);
+};
+export type TableLike = {
+    props: TableProps;
+};
+export type ContentModel = BaseModel & {
+    constructor: {
+        attributes(): AttributeDefinition[];
+        modelName(): {
+            human(): string;
+        };
+    };
+} & Record<string, (() => BaseModel | PrimitiveColumnValue | null | undefined) | object>;
+import React from "react";
 //# sourceMappingURL=column-content.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column-content.d.ts","sourceRoot":"/src/","sources":["table/column-content.jsx"],"names":[],"mappings":"AAQA;IACE;;;;;;;;OAQG;IACH,kDAPG;QAAkB,MAAM,EAAhB,GAAG;QACO,CAAC,EAAX,GAAG;QACW,IAAI,GAAlB,MAAM;QACI,KAAK,EAAf,GAAG;QACa,CAAC;QACP,KAAK,EAAf,GAAG;KACb,EAQA;IANC,YAAoB;IACpB,OAAU;IACV,aAAgB;IAChB,WAAkB;IAClB,YAAU;IACV,WAAkB;IAGpB,mCAQC;IAED,0CAsCC;IAED,eAMC;IAED,qBAAsB,UAAK,SA+B1B;IAED;;;;;;OAMG;IACH,kBAAmB,yBAJhB;QAA6B,YAAY,GAAjC,MAAM,GAAC,MAAM;QACF,KAAK,EAAhB,IAAI;KAGkC,KAFpC,MAAM,CAclB;IAED;;;;;;;OAOG;IACH,sDALG;QAA4B,YAAY,EAAhC,MAAM,GAAC,MAAM;QACS,MAAM,EAA5B,WAAS,MAAM;QACJ,KAAK,EAAhB,IAAI;KACZ,GAAU,MAAM,CAelB;CACF"}
+{"version":3,"file":"column-content.d.ts","sourceRoot":"/src/","sources":["table/column-content.jsx"],"names":[],"mappings":"AA0CA;IACE;;;;;;;;OAQG;IACH,kDAPG;QAA0B,MAAM,EAAxB,WAAW;QACY,CAAC,EAAxB,gBAAgB;QACF,IAAI,GAAlB,MAAM;QACa,KAAK,EAAxB,YAAY;QACO,CAAC,GAApB,WAAW;QACK,KAAK,EAArB,SAAS;KACnB,EAQA;IANC,oBAAoB;IACpB,oBAAU;IACV,aAAgB;IAChB,oBAAkB;IAClB,eAAU;IACV,iBAAkB;IAGpB,+CAWC;IAED,6CAA6C;IAC7C,sCADc,KAAK,CAAC,SAAS,GAAG,SAAS,CA2CxC;IAED,2BAMC;IAED;;;OAGG;IACH,qBAAsB,OAHX,WAGgB,KAFd,KAAK,CAAC,SAAS,CAoC3B;IAED;;;;;;OAMG;IACH,kBAAmB,yBAJhB;QAA6B,YAAY,GAAjC,MAAM,GAAC,MAAM;QACF,KAAK,EAAhB,IAAI;KAGkC,KAFpC,MAAM,CAclB;IAED;;;;;;;OAOG;IACH,sDALG;QAA4B,YAAY,EAAhC,MAAM,GAAC,MAAM;QACS,MAAM,EAA5B,WAAS,MAAM;QACJ,KAAK,EAAhB,IAAI;KACZ,GAAU,MAAM,CAelB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBACuwsB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAzMl2yB,OAAO,uBAAuB,EAAE,SAAS;;eAGzC,MAAM,OAAO,yBAAyB,EAAE,OAAO,GAAG,SAAS;UAC3D,MAAM,MAAM;;mCAGb,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,SAAS,GAAG,SAAS;0BAEhF,oBAAoB,GAAG,oBAAoB,EAAE;+BAC7C,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,KAAK,MAAM;0BACvC,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM;;gBAGtC,MAAM;cACN,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,KAAK,WAAW;WACzD,MAAM,EAAE;;yBAER;IAAC,qBAAqB,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAAC,yBAAyB,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,CAAA;CAAC;wBAC9H;IAAC,KAAK,EAAE,UAAU,CAAA;CAAC;2BAEpB,SAAS,GAAG;IACpB,WAAW,EAAE;QAAC,UAAU,IAAI,mBAAmB,EAAE,CAAC;QAAC,SAAS,IAAI;YAAC,KAAK,IAAI,MAAM,CAAA;SAAC,CAAA;KAAC,CAAA;CACnF,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,SAAS,GAAG,oBAAoB,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC;kBA3BzE,OAAO"}

package/build/table/column-content.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable padded-blocks, react/jsx-one-expression-per-line, sort-imports */
 import { digs } from "diggerize";
 import * as inflection from "inflection";
@@ -6,15 +7,46 @@ import modelCallbackArgs from "./model-callback-args.js";
 import MoneyFormatter from "../money-formatter.js";
 import React from "react";
 import Text from "../utils/text";
+/** @typedef {import("../base-model.js").default} BaseModel */
+/** @typedef {import("../money-formatter.js").MoneyLike} MoneyLike */
+/**
+ * @typedef {object} AttributeDefinition
+ * @property {() => import("../base-model/column.js").default | undefined} getColumn
+ * @property {() => string} name
+ */
+/**
+ * @typedef {string | Date | boolean | number | null | undefined | React.ReactNode | MoneyLike} PrimitiveColumnValue
+ */
+/** @typedef {PrimitiveColumnValue | PrimitiveColumnValue[]} ColumnValue */
+/** @typedef {(format: string, value: Date) => string} LocalizeDateTime */
+/** @typedef {(key: string, args?: object) => string} TranslateFn */
+/**
+ * @typedef {object} TableColumn
+ * @property {string} [attribute]
+ * @property {(args: Record<string, BaseModel | string>) => ColumnValue} [content]
+ * @property {string[]} [path]
+ */
+/** @typedef {{defaultDateFormatName?: string | ((args: object) => string), defaultDateTimeFormatName?: string | ((args: object) => string)}} TableProps */
+/** @typedef {{props: TableProps}} TableLike */
+/**
+ * @typedef {BaseModel & {
+ *   constructor: {attributes(): AttributeDefinition[], modelName(): {human(): string}}
+ * } & Record<string, (() => BaseModel | PrimitiveColumnValue | null | undefined) | object>} ContentModel
+ */
+/**
+ * @param {PrimitiveColumnValue} value
+ * @returns {value is MoneyLike}
+ */
+const isMoneyValue = (value) => MoneyFormatter.isMoney(value);
 export default class ApiMakerTableColumnContent {
     /**
      * @param {object} args
-     * @param {any} args.column
-     * @param {any} args.l
+     * @param {TableColumn} args.column
+     * @param {LocalizeDateTime} args.l
      * @param {string} [args.mode]
-     * @param {any} args.model
-     * @param {Function} [args.t]
-     * @param {any} args.table
+     * @param {ContentModel} args.model
+     * @param {TranslateFn} [args.t]
+     * @param {TableLike} args.table
      */
     constructor({ column, l, mode = "react-native", model, t, table }) {
         this.column = column;
@@ -25,11 +57,13 @@ export default class ApiMakerTableColumnContent {
         this.table = table;
     }
     columnContentFromContentArg() {
-        const args = modelCallbackArgs(this.table, this.model);
+        const args = modelCallbackArgs(
+        /** @type {{props: {modelClass: {modelClassData(): {name: string}}}}} */ (this.table), this.model);
         args.mode = this.mode;
         const value = this.column.content(args);
         return this.presentColumnValue(value);
     }
+    /** @returns {React.ReactNode | undefined} */
     columnsContentFromAttributeAndPath() {
         const { attribute: attributeName } = digs(this.column, "attribute");
         const attributeNameUnderscore = inflection.underscore(attributeName);
@@ -38,7 +72,8 @@ export default class ApiMakerTableColumnContent {
         let currentModel = this.model;
         if (path.length > 0) {
             for (const pathPart of path) {
-                currentModel = currentModel[pathPart]();
+                currentModel = /** @type {ContentModel | null | undefined} */ (
+                /** @type {() => BaseModel | null | undefined} */ (currentModel[pathPart])());
                 if (!currentModel)
                     return;
             }
@@ -49,10 +84,10 @@ export default class ApiMakerTableColumnContent {
         if (currentModel.isAttributeLoaded(attributeName)) {
             value = currentModel[attributeName]();
         }
-        const attribute = currentModel.constructor.attributes().find((attribute) => attribute.name() == attributeNameUnderscore);
+        const attribute = /** @type {AttributeDefinition | undefined} */ (currentModel.constructor.attributes().find((attribute) => attribute.name() == attributeNameUnderscore));
         const modelColumn = attribute?.getColumn();
         if (modelColumn?.getType() == "date" && value) {
-            const contentText = this.presentDateTime({ apiMakerType: "date", value });
+            const contentText = this.presentDateTime({ apiMakerType: "date", value: /** @type {Date} */ (value) });
             if (this.mode == "html") {
                 return contentText;
             }
@@ -70,14 +105,21 @@ export default class ApiMakerTableColumnContent {
             return this.columnsContentFromAttributeAndPath();
         }
     }
+    /**
+     * @param {ColumnValue} value
+     * @returns {React.ReactNode}
+     */
     presentColumnValue = (value) => {
         let contentText;
         if (value instanceof Date) {
             contentText = this.presentDateTime({ value });
         }
-        else if (MoneyFormatter.isMoney(value)) {
+        else if (!Array.isArray(value) && isMoneyValue(value)) {
             contentText = MoneyFormatter.format(value);
         }
+        else if (typeof value == "number") {
+            contentText = String(value);
+        }
         else if (typeof value == "boolean") {
             if (value) {
                 contentText = this.t("js.shared.yes", { defaultValue: "Yes" });
@@ -90,6 +132,7 @@ export default class ApiMakerTableColumnContent {
             contentText = value
                 .map((valuePart) => this.presentColumnValue(valuePart))
                 .filter((valuePart) => Boolean(valuePart))
+                .map((valuePart) => (typeof valuePart == "string" ? valuePart : ""))
                 .join(", ");
         }
         else if (typeof value == "string") {
@@ -97,7 +140,7 @@ export default class ApiMakerTableColumnContent {
         }
         else {
             // Its a React node - just return it and trust the provider to be HTML compatible.
-            return value;
+            return /** @type {React.ReactNode} */ (value);
         }
         if (this.mode == "html") {
             return contentText;
@@ -146,4 +189,4 @@ export default class ApiMakerTableColumnContent {
         return this.l(format, value);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-content.js","sourceRoot":"/src/","sources":["table/column-content.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable padded-blocks, react/jsx-one-expression-per-line, sort-imports */\nimport {digs} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport modelCallbackArgs from \"./model-callback-args.js\"\nimport MoneyFormatter from \"../money-formatter.js\"\nimport React from \"react\"\nimport Text from \"../utils/text\"\n\nexport default class ApiMakerTableColumnContent {\n  /**\n   * @param {object} args\n   * @param {any} args.column\n   * @param {any} args.l\n   * @param {string} [args.mode]\n   * @param {any} args.model\n   * @param {Function} [args.t]\n   * @param {any} args.table\n   */\n  constructor({column, l, mode = \"react-native\", model, t, table}) {\n    this.column = column\n    this.l = l\n    this.mode = mode\n    this.model = model\n    this.t = t\n    this.table = table\n  }\n\n  columnContentFromContentArg() {\n    const args = modelCallbackArgs(this.table, this.model)\n\n    args.mode = this.mode\n\n    const value = this.column.content(args)\n\n    return this.presentColumnValue(value)\n  }\n\n  columnsContentFromAttributeAndPath() {\n    const {attribute: attributeName} = digs(this.column, \"attribute\")\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n    const path = this.column.path || []\n    let value\n    let currentModel = this.model\n\n    if (path.length > 0) {\n      for (const pathPart of path) {\n        currentModel = currentModel[pathPart]()\n        if (!currentModel) return\n      }\n    }\n\n    if (!(attributeName in currentModel)) {\n      throw new Error(`${currentModel.constructor.modelName().human()} doesn't respond to ${attributeName}`)\n    }\n\n    if (currentModel.isAttributeLoaded(attributeName)) {\n      value = currentModel[attributeName]()\n    }\n\n    const attribute = currentModel.constructor.attributes().find((attribute) => attribute.name() == attributeNameUnderscore)\n    const modelColumn = attribute?.getColumn()\n\n    if (modelColumn?.getType() == \"date\" && value) {\n      const contentText = this.presentDateTime({apiMakerType: \"date\", value})\n\n      if (this.mode == \"html\") {\n        return contentText\n      } else {\n        return (\n          <Text>{contentText}</Text>\n        )\n      }\n    }\n\n    return this.presentColumnValue(value)\n  }\n\n  content() {\n    if (this.column.content) {\n      return this.columnContentFromContentArg()\n    } else if (!this.column.content && this.column.attribute) {\n      return this.columnsContentFromAttributeAndPath()\n    }\n  }\n\n  presentColumnValue = (value) => {\n    let contentText\n\n    if (value instanceof Date) {\n      contentText = this.presentDateTime({value})\n    } else if (MoneyFormatter.isMoney(value)) {\n      contentText = MoneyFormatter.format(value)\n    } else if (typeof value == \"boolean\") {\n      if (value) {\n        contentText = this.t(\"js.shared.yes\", {defaultValue: \"Yes\"})\n      } else {\n        contentText = this.t(\"js.shared.no\", {defaultValue: \"No\"})\n      }\n    } else if (Array.isArray(value)) {\n      contentText = value\n        .map((valuePart) => this.presentColumnValue(valuePart))\n        .filter((valuePart) => Boolean(valuePart))\n        .join(\", \")\n\n    } else if (typeof value == \"string\") {\n      contentText = value\n    } else {\n      // Its a React node - just return it and trust the provider to be HTML compatible.\n      return value\n    }\n\n    if (this.mode == \"html\") {\n      return contentText\n    }\n\n    return <Text>{contentText}</Text>\n  }\n\n  /**\n   * Presents date and datetime values using either translation-format keys or formatter callbacks.\n   * @param {object} args\n   * @param {\"date\"|\"time\"} [args.apiMakerType]\n   * @param {Date} args.value\n   * @returns {string}\n   */\n  presentDateTime = ({apiMakerType = \"time\", value}) => {\n    if (!apiMakerType || apiMakerType == \"time\") {\n      const dateTimeFormatName = this.table.props.defaultDateTimeFormatName || \"time.formats.default\"\n\n      return this.presentDateTimeValue({apiMakerType: \"time\", format: dateTimeFormatName, value})\n    } else if (apiMakerType == \"date\") {\n      const dateFormatName = this.table.props.defaultDateFormatName || \"date.formats.default\"\n\n      return this.presentDateTimeValue({apiMakerType: \"date\", format: dateFormatName, value})\n    } else {\n      throw new Error(`Unhandled type: ${apiMakerType}`)\n    }\n  }\n\n  /**\n   * Resolves a date format key or executes a custom formatter callback.\n   * @param {object} args\n   * @param {\"date\"|\"time\"} args.apiMakerType\n   * @param {Function|string} args.format\n   * @param {Date} args.value\n   * @returns {string}\n   */\n  presentDateTimeValue({apiMakerType, format, value}) {\n    if (typeof format == \"function\") {\n      return format({\n        apiMakerType,\n        column: this.column,\n        l: this.l,\n        model: this.model,\n        table: this.table,\n        value\n      })\n    }\n\n    return this.l(format, value)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-content.js","sourceRoot":"/src/","sources":["table/column-content.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable padded-blocks, react/jsx-one-expression-per-line, sort-imports */\nimport {digs} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport modelCallbackArgs from \"./model-callback-args.js\"\nimport MoneyFormatter from \"../money-formatter.js\"\nimport React from \"react\"\nimport Text from \"../utils/text\"\n\n/** @typedef {import(\"../base-model.js\").default} BaseModel */\n/** @typedef {import(\"../money-formatter.js\").MoneyLike} MoneyLike */\n/**\n * @typedef {object} AttributeDefinition\n * @property {() => import(\"../base-model/column.js\").default | undefined} getColumn\n * @property {() => string} name\n */\n/**\n * @typedef {string | Date | boolean | number | null | undefined | React.ReactNode | MoneyLike} PrimitiveColumnValue\n */\n/** @typedef {PrimitiveColumnValue | PrimitiveColumnValue[]} ColumnValue */\n/** @typedef {(format: string, value: Date) => string} LocalizeDateTime */\n/** @typedef {(key: string, args?: object) => string} TranslateFn */\n/**\n * @typedef {object} TableColumn\n * @property {string} [attribute]\n * @property {(args: Record<string, BaseModel | string>) => ColumnValue} [content]\n * @property {string[]} [path]\n */\n/** @typedef {{defaultDateFormatName?: string | ((args: object) => string), defaultDateTimeFormatName?: string | ((args: object) => string)}} TableProps */\n/** @typedef {{props: TableProps}} TableLike */\n/**\n * @typedef {BaseModel & {\n *   constructor: {attributes(): AttributeDefinition[], modelName(): {human(): string}}\n * } & Record<string, (() => BaseModel | PrimitiveColumnValue | null | undefined) | object>} ContentModel\n */\n\n/**\n * @param {PrimitiveColumnValue} value\n * @returns {value is MoneyLike}\n */\nconst isMoneyValue = (value) => MoneyFormatter.isMoney(value)\n\nexport default class ApiMakerTableColumnContent {\n  /**\n   * @param {object} args\n   * @param {TableColumn} args.column\n   * @param {LocalizeDateTime} args.l\n   * @param {string} [args.mode]\n   * @param {ContentModel} args.model\n   * @param {TranslateFn} [args.t]\n   * @param {TableLike} args.table\n   */\n  constructor({column, l, mode = \"react-native\", model, t, table}) {\n    this.column = column\n    this.l = l\n    this.mode = mode\n    this.model = model\n    this.t = t\n    this.table = table\n  }\n\n  columnContentFromContentArg() {\n    const args = modelCallbackArgs(\n      /** @type {{props: {modelClass: {modelClassData(): {name: string}}}}} */ (this.table),\n      this.model\n    )\n\n    args.mode = this.mode\n\n    const value = this.column.content(args)\n\n    return this.presentColumnValue(value)\n  }\n\n  /** @returns {React.ReactNode | undefined} */\n  columnsContentFromAttributeAndPath() {\n    const {attribute: attributeName} = digs(this.column, \"attribute\")\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n    const path = this.column.path || []\n    let value\n    let currentModel = this.model\n\n    if (path.length > 0) {\n      for (const pathPart of path) {\n        currentModel = /** @type {ContentModel | null | undefined} */ (\n          /** @type {() => BaseModel | null | undefined} */ (currentModel[pathPart])()\n        )\n        if (!currentModel) return\n      }\n    }\n\n    if (!(attributeName in currentModel)) {\n      throw new Error(`${currentModel.constructor.modelName().human()} doesn't respond to ${attributeName}`)\n    }\n\n    if (currentModel.isAttributeLoaded(attributeName)) {\n      value = currentModel[attributeName]()\n    }\n\n    const attribute = /** @type {AttributeDefinition | undefined} */ (\n      currentModel.constructor.attributes().find((attribute) => attribute.name() == attributeNameUnderscore)\n    )\n    const modelColumn = attribute?.getColumn()\n\n    if (modelColumn?.getType() == \"date\" && value) {\n      const contentText = this.presentDateTime({apiMakerType: \"date\", value: /** @type {Date} */ (value)})\n\n      if (this.mode == \"html\") {\n        return contentText\n      } else {\n        return (\n          <Text>{contentText}</Text>\n        )\n      }\n    }\n\n    return this.presentColumnValue(value)\n  }\n\n  content() {\n    if (this.column.content) {\n      return this.columnContentFromContentArg()\n    } else if (!this.column.content && this.column.attribute) {\n      return this.columnsContentFromAttributeAndPath()\n    }\n  }\n\n  /**\n   * @param {ColumnValue} value\n   * @returns {React.ReactNode}\n   */\n  presentColumnValue = (value) => {\n    let contentText\n\n    if (value instanceof Date) {\n      contentText = this.presentDateTime({value})\n    } else if (!Array.isArray(value) && isMoneyValue(value)) {\n      contentText = MoneyFormatter.format(value)\n    } else if (typeof value == \"number\") {\n      contentText = String(value)\n    } else if (typeof value == \"boolean\") {\n      if (value) {\n        contentText = this.t(\"js.shared.yes\", {defaultValue: \"Yes\"})\n      } else {\n        contentText = this.t(\"js.shared.no\", {defaultValue: \"No\"})\n      }\n    } else if (Array.isArray(value)) {\n      contentText = value\n        .map((valuePart) => this.presentColumnValue(valuePart))\n        .filter((valuePart) => Boolean(valuePart))\n        .map((valuePart) => (typeof valuePart == \"string\" ? valuePart : \"\"))\n        .join(\", \")\n\n    } else if (typeof value == \"string\") {\n      contentText = value\n    } else {\n      // Its a React node - just return it and trust the provider to be HTML compatible.\n      return /** @type {React.ReactNode} */ (value)\n    }\n\n    if (this.mode == \"html\") {\n      return contentText\n    }\n\n    return <Text>{contentText}</Text>\n  }\n\n  /**\n   * Presents date and datetime values using either translation-format keys or formatter callbacks.\n   * @param {object} args\n   * @param {\"date\"|\"time\"} [args.apiMakerType]\n   * @param {Date} args.value\n   * @returns {string}\n   */\n  presentDateTime = ({apiMakerType = \"time\", value}) => {\n    if (!apiMakerType || apiMakerType == \"time\") {\n      const dateTimeFormatName = this.table.props.defaultDateTimeFormatName || \"time.formats.default\"\n\n      return this.presentDateTimeValue({apiMakerType: \"time\", format: dateTimeFormatName, value})\n    } else if (apiMakerType == \"date\") {\n      const dateFormatName = this.table.props.defaultDateFormatName || \"date.formats.default\"\n\n      return this.presentDateTimeValue({apiMakerType: \"date\", format: dateFormatName, value})\n    } else {\n      throw new Error(`Unhandled type: ${apiMakerType}`)\n    }\n  }\n\n  /**\n   * Resolves a date format key or executes a custom formatter callback.\n   * @param {object} args\n   * @param {\"date\"|\"time\"} args.apiMakerType\n   * @param {Function|string} args.format\n   * @param {Date} args.value\n   * @returns {string}\n   */\n  presentDateTimeValue({apiMakerType, format, value}) {\n    if (typeof format == \"function\") {\n      return format({\n        apiMakerType,\n        column: this.column,\n        l: this.l,\n        model: this.model,\n        table: this.table,\n        value\n      })\n    }\n\n    return this.l(format, value)\n  }\n}\n"]}

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

@@ -1,3 +1,12 @@
-/** Resolve a unique column identifier. */
-export default function columnIdentifier(column: any): any;
+/**
+ * Resolve a unique column identifier.
+ * @param {{attribute?: string, identifier?: string, path?: string[], sortKey?: string}} column
+ * @returns {string}
+ */
+export default function columnIdentifier(column: {
+    attribute?: string;
+    identifier?: string;
+    path?: string[];
+    sortKey?: string;
+}): string;
 //# sourceMappingURL=column-identifier.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column-identifier.d.ts","sourceRoot":"/src/","sources":["table/column-identifier.js"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,2DAsBC"}
+{"version":3,"file":"column-identifier.d.ts","sourceRoot":"/src/","sources":["table/column-identifier.js"],"names":[],"mappings":"AACA;;;;GAIG;AACH,iDAHW;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,GAC1E,MAAM,CAwBlB"}

package/build/table/column-identifier.js

@@ -1,4 +1,9 @@
-/** Resolve a unique column identifier. */
+// @ts-check
+/**
+ * Resolve a unique column identifier.
+ * @param {{attribute?: string, identifier?: string, path?: string[], sortKey?: string}} column
+ * @returns {string}
+ */
 export default function columnIdentifier(column) {
     if ("identifier" in column)
         return column.identifier;
@@ -18,4 +23,4 @@ export default function columnIdentifier(column) {
         throw new Error(`Couldn't figure out the identifier for that column: ${JSON.stringify(column)}`);
     return parts.join("--");
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLWlkZW50aWZpZXIuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInRhYmxlL2NvbHVtbi1pZGVudGlmaWVyLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBDQUEwQztBQUMxQyxNQUFNLENBQUMsT0FBTyxVQUFVLGdCQUFnQixDQUFDLE1BQU07SUFDN0MsSUFBSSxZQUFZLElBQUksTUFBTTtRQUFFLE9BQU8sTUFBTSxDQUFDLFVBQVUsQ0FBQTtJQUVwRCxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUE7SUFFaEIsSUFBSSxNQUFNLElBQUksTUFBTSxFQUFFLENBQUM7UUFDckIsS0FBSyxNQUFNLFFBQVEsSUFBSSxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDbkMsS0FBSyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUN0QixDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksV0FBVyxJQUFJLE1BQU0sRUFBRSxDQUFDO1FBQzFCLEtBQUssQ0FBQyxJQUFJLENBQUMsYUFBYSxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQTtJQUM3QyxDQUFDO0lBRUQsSUFBSSxTQUFTLElBQUksTUFBTSxFQUFFLENBQUM7UUFDeEIsS0FBSyxDQUFDLElBQUksQ0FBQyxZQUFZLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFBO0lBQzFDLENBQUM7SUFFRCxJQUFJLEtBQUssQ0FBQyxNQUFNLElBQUksQ0FBQztRQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsdURBQXVELElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBRXZILE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtBQUN6QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIFJlc29sdmUgYSB1bmlxdWUgY29sdW1uIGlkZW50aWZpZXIuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBjb2x1bW5JZGVudGlmaWVyKGNvbHVtbikge1xuICBpZiAoXCJpZGVudGlmaWVyXCIgaW4gY29sdW1uKSByZXR1cm4gY29sdW1uLmlkZW50aWZpZXJcblxuICBjb25zdCBwYXJ0cyA9IFtdXG5cbiAgaWYgKFwicGF0aFwiIGluIGNvbHVtbikge1xuICAgIGZvciAoY29uc3QgcGF0aFBhcnQgb2YgY29sdW1uLnBhdGgpIHtcbiAgICAgIHBhcnRzLnB1c2gocGF0aFBhcnQpXG4gICAgfVxuICB9XG5cbiAgaWYgKFwiYXR0cmlidXRlXCIgaW4gY29sdW1uKSB7XG4gICAgcGFydHMucHVzaChgYXR0cmlidXRlLSR7Y29sdW1uLmF0dHJpYnV0ZX1gKVxuICB9XG5cbiAgaWYgKFwic29ydEtleVwiIGluIGNvbHVtbikge1xuICAgIHBhcnRzLnB1c2goYHNvcnQta2V5LSR7Y29sdW1uLnNvcnRLZXl9YClcbiAgfVxuXG4gIGlmIChwYXJ0cy5sZW5ndGggPT0gMCkgdGhyb3cgbmV3IEVycm9yKGBDb3VsZG4ndCBmaWd1cmUgb3V0IHRoZSBpZGVudGlmaWVyIGZvciB0aGF0IGNvbHVtbjogJHtKU09OLnN0cmluZ2lmeShjb2x1bW4pfWApXG5cbiAgcmV0dXJuIHBhcnRzLmpvaW4oXCItLVwiKVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,3 +1,12 @@
-/** Returns whether a table column should be visible. */
-export default function columnVisible(column: any, tableSettingColumn: any): any;
+/**
+ * Returns whether a table column should be visible.
+ * @param {{defaultVisible?: boolean} | undefined} column
+ * @param {{visible(): boolean | null}} tableSettingColumn
+ * @returns {boolean}
+ */
+export default function columnVisible(column: {
+    defaultVisible?: boolean;
+} | undefined, tableSettingColumn: {
+    visible(): boolean | null;
+}): boolean;
 //# sourceMappingURL=column-visible.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column-visible.d.ts","sourceRoot":"/src/","sources":["table/column-visible.js"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,iFAMC"}
+{"version":3,"file":"column-visible.d.ts","sourceRoot":"/src/","sources":["table/column-visible.js"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,8CAJW;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAC,GAAG,SAAS,sBACtC;IAAC,OAAO,IAAI,OAAO,GAAG,IAAI,CAAA;CAAC,GACzB,OAAO,CAQnB"}

package/build/table/column-visible.js

@@ -1,4 +1,10 @@
-/** Returns whether a table column should be visible. */
+// @ts-check
+/**
+ * Returns whether a table column should be visible.
+ * @param {{defaultVisible?: boolean} | undefined} column
+ * @param {{visible(): boolean | null}} tableSettingColumn
+ * @returns {boolean}
+ */
 export default function columnVisible(column, tableSettingColumn) {
     if (tableSettingColumn.visible() !== null)
         return tableSettingColumn.visible();
@@ -8,4 +14,4 @@ export default function columnVisible(column, tableSettingColumn) {
         return column.defaultVisible;
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXZpc2libGUuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInRhYmxlL2NvbHVtbi12aXNpYmxlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdEQUF3RDtBQUN4RCxNQUFNLENBQUMsT0FBTyxVQUFVLGFBQWEsQ0FBQyxNQUFNLEVBQUUsa0JBQWtCO0lBQzlELElBQUksa0JBQWtCLENBQUMsT0FBTyxFQUFFLEtBQUssSUFBSTtRQUFFLE9BQU8sa0JBQWtCLENBQUMsT0FBTyxFQUFFLENBQUE7SUFDOUUsSUFBSSxDQUFDLE1BQU07UUFBRSxPQUFPLEtBQUssQ0FBQTtJQUN6QixJQUFJLGdCQUFnQixJQUFJLE1BQU07UUFBRSxPQUFPLE1BQU0sQ0FBQyxjQUFjLENBQUE7SUFFNUQsT0FBTyxJQUFJLENBQUE7QUFDYixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIFJldHVybnMgd2hldGhlciBhIHRhYmxlIGNvbHVtbiBzaG91bGQgYmUgdmlzaWJsZS4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGNvbHVtblZpc2libGUoY29sdW1uLCB0YWJsZVNldHRpbmdDb2x1bW4pIHtcbiAgaWYgKHRhYmxlU2V0dGluZ0NvbHVtbi52aXNpYmxlKCkgIT09IG51bGwpIHJldHVybiB0YWJsZVNldHRpbmdDb2x1bW4udmlzaWJsZSgpXG4gIGlmICghY29sdW1uKSByZXR1cm4gZmFsc2VcbiAgaWYgKFwiZGVmYXVsdFZpc2libGVcIiBpbiBjb2x1bW4pIHJldHVybiBjb2x1bW4uZGVmYXVsdFZpc2libGVcblxuICByZXR1cm4gdHJ1ZVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXZpc2libGUuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInRhYmxlL2NvbHVtbi12aXNpYmxlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFDWjs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxPQUFPLFVBQVUsYUFBYSxDQUFDLE1BQU0sRUFBRSxrQkFBa0I7SUFDOUQsSUFBSSxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsS0FBSyxJQUFJO1FBQUUsT0FBTyxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsQ0FBQTtJQUM5RSxJQUFJLENBQUMsTUFBTTtRQUFFLE9BQU8sS0FBSyxDQUFBO0lBQ3pCLElBQUksZ0JBQWdCLElBQUksTUFBTTtRQUFFLE9BQU8sTUFBTSxDQUFDLGNBQWMsQ0FBQTtJQUU1RCxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbi8qKlxuICogUmV0dXJucyB3aGV0aGVyIGEgdGFibGUgY29sdW1uIHNob3VsZCBiZSB2aXNpYmxlLlxuICogQHBhcmFtIHt7ZGVmYXVsdFZpc2libGU/OiBib29sZWFufSB8IHVuZGVmaW5lZH0gY29sdW1uXG4gKiBAcGFyYW0ge3t2aXNpYmxlKCk6IGJvb2xlYW4gfCBudWxsfX0gdGFibGVTZXR0aW5nQ29sdW1uXG4gKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gY29sdW1uVmlzaWJsZShjb2x1bW4sIHRhYmxlU2V0dGluZ0NvbHVtbikge1xuICBpZiAodGFibGVTZXR0aW5nQ29sdW1uLnZpc2libGUoKSAhPT0gbnVsbCkgcmV0dXJuIHRhYmxlU2V0dGluZ0NvbHVtbi52aXNpYmxlKClcbiAgaWYgKCFjb2x1bW4pIHJldHVybiBmYWxzZVxuICBpZiAoXCJkZWZhdWx0VmlzaWJsZVwiIGluIGNvbHVtbikgcmV0dXJuIGNvbHVtbi5kZWZhdWx0VmlzaWJsZVxuXG4gIHJldHVybiB0cnVlXG59XG4iXX0=

package/build/table/components/column.d.ts

@@ -1,4 +1,6 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = Record<string, never>;
+export type State = Record<string, never>;
 import React from "react";
 //# sourceMappingURL=column.d.ts.map

package/build/table/components/column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","sourceRoot":"/src/","sources":["table/components/column.jsx"],"names":[],"mappings":";;kBAGkB,OAAO"}
+{"version":3,"file":"column.d.ts","sourceRoot":"/src/","sources":["table/components/column.jsx"],"names":[],"mappings":";;oBAOc,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;oBACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBALjB,OAAO"}

package/build/table/components/column.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
-import BaseComponent from "../../base-component";
 import memo from "set-state-compare/build/memo.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 { Animated } from "react-native";
-export default memo(shapeComponent(class SharedTableColumn extends BaseComponent {
+/** @typedef {Record<string, never>} Props */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class SharedTableColumn extends ShapeComponent {
     render() {
         const { dataSet, ...restProps } = this.props;
         const actualDataSet = Object.assign(// eslint-disable-line prefer-object-spread
@@ -13,4 +15,4 @@ export default memo(shapeComponent(class SharedTableColumn extends BaseComponent
         return (_jsx(Animated.View, { dataSet: actualDataSet, ...restProps }));
     }
 }));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJ0YWJsZS9jb21wb25lbnRzL2NvbHVtbi5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGlDQUFpQztBQUNqQyxPQUFPLGFBQWEsTUFBTSxzQkFBc0IsQ0FBQTtBQUNoRCxPQUFPLElBQUksTUFBTSxpQ0FBaUMsQ0FBQTtBQUNsRCxPQUFPLEtBQUssTUFBTSxPQUFPLENBQUE7QUFDekIsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLDRDQUE0QyxDQUFBO0FBQ3pFLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxjQUFjLENBQUE7QUFFckMsZUFBZSxJQUFJLENBQUMsY0FBYyxDQUFDLE1BQU0saUJBQWtCLFNBQVEsYUFBYTtJQUM5RSxNQUFNO1FBQ0osTUFBTSxFQUFDLE9BQU8sRUFBRSxHQUFHLFNBQVMsRUFBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUE7UUFDMUMsTUFBTSxhQUFhLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBRSwyQ0FBMkM7UUFDOUUsRUFBQyxTQUFTLEVBQUUsbUNBQW1DLEVBQUMsRUFDaEQsT0FBTyxDQUNSLENBQUE7UUFFRCxPQUFPLENBQ0wsS0FBQyxRQUFRLENBQUMsSUFBSSxJQUFDLE9BQU8sRUFBRSxhQUFhLEtBQU0sU0FBUyxHQUFJLENBQ3pELENBQUE7SUFDSCxDQUFDO0NBQ0YsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBzb3J0LWltcG9ydHMgKi9cbmltcG9ydCBCYXNlQ29tcG9uZW50IGZyb20gXCIuLi8uLi9iYXNlLWNvbXBvbmVudFwiXG5pbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvYnVpbGQvbWVtby5qc1wiXG5pbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCJcbmltcG9ydCB7c2hhcGVDb21wb25lbnR9IGZyb20gXCJzZXQtc3RhdGUtY29tcGFyZS9idWlsZC9zaGFwZS1jb21wb25lbnQuanNcIlxuaW1wb3J0IHtBbmltYXRlZH0gZnJvbSBcInJlYWN0LW5hdGl2ZVwiXG5cbmV4cG9ydCBkZWZhdWx0IG1lbW8oc2hhcGVDb21wb25lbnQoY2xhc3MgU2hhcmVkVGFibGVDb2x1bW4gZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcbiAgcmVuZGVyKCkge1xuICAgIGNvbnN0IHtkYXRhU2V0LCAuLi5yZXN0UHJvcHN9ID0gdGhpcy5wcm9wc1xuICAgIGNvbnN0IGFjdHVhbERhdGFTZXQgPSBPYmplY3QuYXNzaWduKCAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIHByZWZlci1vYmplY3Qtc3ByZWFkXG4gICAgICB7Y29tcG9uZW50OiBcImFwaS1tYWtlci90YWJsZS9jb21wb25lbnRzL2NvbHVtblwifSxcbiAgICAgIGRhdGFTZXRcbiAgICApXG5cbiAgICByZXR1cm4gKFxuICAgICAgPEFuaW1hdGVkLlZpZXcgZGF0YVNldD17YWN0dWFsRGF0YVNldH0gey4uLnJlc3RQcm9wc30gLz5cbiAgICApXG4gIH1cbn0pKVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/components/flat-list.d.ts

@@ -1,4 +1,6 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = import("react-native").FlatListProps<object>;
+export type State = Record<string, never>;
 import React from "react";
 //# sourceMappingURL=flat-list.d.ts.map

package/build/table/components/flat-list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flat-list.d.ts","sourceRoot":"/src/","sources":["table/components/flat-list.jsx"],"names":[],"mappings":";;kBAIkB,OAAO"}
+{"version":3,"file":"flat-list.d.ts","sourceRoot":"/src/","sources":["table/components/flat-list.jsx"],"names":[],"mappings":";;oBAOc,OAAO,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC;oBAC5C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBAJjB,OAAO"}

package/build/table/components/flat-list.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
-import BaseComponent from "../../base-component";
 import { FlatList } from "react-native";
 import memo from "set-state-compare/build/memo.js";
 import React from "react";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
-export default memo(shapeComponent(class SharedTagble extends BaseComponent {
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
+/** @typedef {import("react-native").FlatListProps<object>} Props */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class SharedTagble extends ShapeComponent {
     render() {
         const { style, ...restProps } = this.props;
         const actualStyle = Object.assign(// eslint-disable-line prefer-object-spread
@@ -13,4 +15,4 @@ export default memo(shapeComponent(class SharedTagble extends BaseComponent {
         return (_jsx(FlatList, { style: actualStyle, ...(restProps) }));
     }
 }));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhdC1saXN0LmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJ0YWJsZS9jb21wb25lbnRzL2ZsYXQtbGlzdC5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGlDQUFpQztBQUNqQyxPQUFPLGFBQWEsTUFBTSxzQkFBc0IsQ0FBQTtBQUNoRCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sY0FBYyxDQUFBO0FBQ3JDLE9BQU8sSUFBSSxNQUFNLGlDQUFpQyxDQUFBO0FBQ2xELE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQTtBQUN6QixPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sNENBQTRDLENBQUE7QUFFekUsZUFBZSxJQUFJLENBQUMsY0FBYyxDQUFDLE1BQU0sWUFBYSxTQUFRLGFBQWE7SUFDekUsTUFBTTtRQUNKLE1BQU0sRUFBQyxLQUFLLEVBQUUsR0FBRyxTQUFTLEVBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFBO1FBQ3hDLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUUsMkNBQTJDO1FBQzVFLEVBQUMsS0FBSyxFQUFFLE1BQU0sRUFBQyxFQUNmLEtBQUssQ0FDTixDQUFBO1FBRUQsT0FBTyxDQUNMLEtBQUMsUUFBUSxJQUFDLEtBQUssRUFBRSxXQUFXLEtBQXlCLENBQUMsU0FBUyxDQUFDLEdBQUksQ0FDckUsQ0FBQTtJQUNILENBQUM7Q0FDRixDQUFDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIHNvcnQtaW1wb3J0cyAqL1xuaW1wb3J0IEJhc2VDb21wb25lbnQgZnJvbSBcIi4uLy4uL2Jhc2UtY29tcG9uZW50XCJcbmltcG9ydCB7RmxhdExpc3R9IGZyb20gXCJyZWFjdC1uYXRpdmVcIlxuaW1wb3J0IG1lbW8gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL2J1aWxkL21lbW8uanNcIlxuaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiXG5pbXBvcnQge3NoYXBlQ29tcG9uZW50fSBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvYnVpbGQvc2hhcGUtY29tcG9uZW50LmpzXCJcblxuZXhwb3J0IGRlZmF1bHQgbWVtbyhzaGFwZUNvbXBvbmVudChjbGFzcyBTaGFyZWRUYWdibGUgZXh0ZW5kcyBCYXNlQ29tcG9uZW50IHtcbiAgcmVuZGVyKCkge1xuICAgIGNvbnN0IHtzdHlsZSwgLi4ucmVzdFByb3BzfSA9IHRoaXMucHJvcHNcbiAgICBjb25zdCBhY3R1YWxTdHlsZSA9IE9iamVjdC5hc3NpZ24oIC8vIGVzbGludC1kaXNhYmxlLWxpbmUgcHJlZmVyLW9iamVjdC1zcHJlYWRcbiAgICAgIHt3aWR0aDogXCIxMDAlXCJ9LFxuICAgICAgc3R5bGVcbiAgICApXG5cbiAgICByZXR1cm4gKFxuICAgICAgPEZsYXRMaXN0IHN0eWxlPXthY3R1YWxTdHlsZX0gey4uLi8qKiBAdHlwZSB7YW55fSAqLyAocmVzdFByb3BzKX0gLz5cbiAgICApXG4gIH1cbn0pKVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/components/header.d.ts

@@ -1,4 +1,6 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = Record<string, never>;
+export type State = Record<string, never>;
 import React from "react";
 //# sourceMappingURL=header.d.ts.map

package/build/table/components/header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header.d.ts","sourceRoot":"/src/","sources":["table/components/header.jsx"],"names":[],"mappings":";;kBAIkB,OAAO"}
+{"version":3,"file":"header.d.ts","sourceRoot":"/src/","sources":["table/components/header.jsx"],"names":[],"mappings":";;oBAQc,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;oBACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBALjB,OAAO"}

package/build/table/components/header.js

@@ -1,12 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
-import BaseComponent from "../../base-component";
 import classNames from "classnames"; // eslint-disable-line import/no-unresolved
 import memo from "set-state-compare/build/memo.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 { Animated } from "react-native";
-export default memo(shapeComponent(class SharedTableHeader extends BaseComponent {
+/** @typedef {Record<string, never>} Props */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class SharedTableHeader extends ShapeComponent {
     render() {
         const { dataSet, ...restProps } = this.props;
         const { component, ...restDataSet } = dataSet || {};
@@ -15,4 +17,4 @@ export default memo(shapeComponent(class SharedTableHeader extends BaseComponent
         return (_jsx(Animated.View, { dataSet: actualDataSet, ...restProps }));
     }
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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