@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/table/model-callback-args.d.ts

@@ -1,5 +1,118 @@
-/** Build callback args for table model actions. */
-export default function modelCallbackArgs(table: any, model: any): {
-    model: any;
+/** @typedef {import("../base-model.js").default} BaseModel */
+/**
+ * Build callback args for table model actions.
+ * @param {{props: {modelClass: {modelClassData(): {name: string}}}}} table
+ * @param {BaseModel} model
+ * @returns {Record<string, BaseModel | string>}
+ */
+export default function modelCallbackArgs(table: {
+    props: {
+        modelClass: {
+            modelClassData(): {
+                name: string;
+            };
+        };
+    };
+}, model: BaseModel): Record<string, BaseModel | 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;
 };
 //# sourceMappingURL=model-callback-args.d.ts.map

package/build/table/model-callback-args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-callback-args.d.ts","sourceRoot":"/src/","sources":["table/model-callback-args.js"],"names":[],"mappings":"AAEA,mDAAmD;AACnD;;EAOC"}
+{"version":3,"file":"model-callback-args.d.ts","sourceRoot":"/src/","sources":["table/model-callback-args.js"],"names":[],"mappings":"AAGA,8DAA8D;AAE9D;;;;;GAKG;AACH,iDAJW;IAAC,KAAK,EAAE;QAAC,UAAU,EAAE;YAAC,cAAc,IAAI;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAC,CAAA;SAAC,CAAA;KAAC,CAAA;CAAC,SACzD,SAAS,GACP,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,CAS9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBACi44B,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC"}

package/build/table/model-callback-args.js

@@ -1,9 +1,16 @@
+// @ts-check
 import * as inflection from "inflection";
-/** Build callback args for table model actions. */
+/** @typedef {import("../base-model.js").default} BaseModel */
+/**
+ * Build callback args for table model actions.
+ * @param {{props: {modelClass: {modelClassData(): {name: string}}}}} table
+ * @param {BaseModel} model
+ * @returns {Record<string, BaseModel | string>}
+ */
 export default function modelCallbackArgs(table, model) {
     const modelArgName = inflection.camelize(table.props.modelClass.modelClassData().name, true);
-    const modelCallbackArgs = { model };
+    const modelCallbackArgs = /** @type {Record<string, BaseModel | string>} */ ({ model });
     modelCallbackArgs[modelArgName] = model;
     return modelCallbackArgs;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwtY2FsbGJhY2stYXJncy5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidGFibGUvbW9kZWwtY2FsbGJhY2stYXJncy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssVUFBVSxNQUFNLFlBQVksQ0FBQTtBQUV4QyxtREFBbUQ7QUFDbkQsTUFBTSxDQUFDLE9BQU8sVUFBVSxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsS0FBSztJQUNwRCxNQUFNLFlBQVksR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLGNBQWMsRUFBRSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQTtJQUM1RixNQUFNLGlCQUFpQixHQUFHLEVBQUMsS0FBSyxFQUFDLENBQUE7SUFFakMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLEdBQUcsS0FBSyxDQUFBO0lBRXZDLE9BQU8saUJBQWlCLENBQUE7QUFDMUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGluZmxlY3Rpb24gZnJvbSBcImluZmxlY3Rpb25cIlxuXG4vKiogQnVpbGQgY2FsbGJhY2sgYXJncyBmb3IgdGFibGUgbW9kZWwgYWN0aW9ucy4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIG1vZGVsQ2FsbGJhY2tBcmdzKHRhYmxlLCBtb2RlbCkge1xuICBjb25zdCBtb2RlbEFyZ05hbWUgPSBpbmZsZWN0aW9uLmNhbWVsaXplKHRhYmxlLnByb3BzLm1vZGVsQ2xhc3MubW9kZWxDbGFzc0RhdGEoKS5uYW1lLCB0cnVlKVxuICBjb25zdCBtb2RlbENhbGxiYWNrQXJncyA9IHttb2RlbH1cblxuICBtb2RlbENhbGxiYWNrQXJnc1ttb2RlbEFyZ05hbWVdID0gbW9kZWxcblxuICByZXR1cm4gbW9kZWxDYWxsYmFja0FyZ3Ncbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwtY2FsbGJhY2stYXJncy5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidGFibGUvbW9kZWwtY2FsbGJhY2stYXJncy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osT0FBTyxLQUFLLFVBQVUsTUFBTSxZQUFZLENBQUE7QUFFeEMsOERBQThEO0FBRTlEOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sVUFBVSxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsS0FBSztJQUNwRCxNQUFNLFlBQVksR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLGNBQWMsRUFBRSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQTtJQUM1RixNQUFNLGlCQUFpQixHQUFHLGlEQUFpRCxDQUFDLENBQUMsRUFBQyxLQUFLLEVBQUMsQ0FBQyxDQUFBO0lBRXJGLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxHQUFHLEtBQUssQ0FBQTtJQUV2QyxPQUFPLGlCQUFpQixDQUFBO0FBQzFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbmltcG9ydCAqIGFzIGluZmxlY3Rpb24gZnJvbSBcImluZmxlY3Rpb25cIlxuXG4vKiogQHR5cGVkZWYge2ltcG9ydChcIi4uL2Jhc2UtbW9kZWwuanNcIikuZGVmYXVsdH0gQmFzZU1vZGVsICovXG5cbi8qKlxuICogQnVpbGQgY2FsbGJhY2sgYXJncyBmb3IgdGFibGUgbW9kZWwgYWN0aW9ucy5cbiAqIEBwYXJhbSB7e3Byb3BzOiB7bW9kZWxDbGFzczoge21vZGVsQ2xhc3NEYXRhKCk6IHtuYW1lOiBzdHJpbmd9fX19fSB0YWJsZVxuICogQHBhcmFtIHtCYXNlTW9kZWx9IG1vZGVsXG4gKiBAcmV0dXJucyB7UmVjb3JkPHN0cmluZywgQmFzZU1vZGVsIHwgc3RyaW5nPn1cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gbW9kZWxDYWxsYmFja0FyZ3ModGFibGUsIG1vZGVsKSB7XG4gIGNvbnN0IG1vZGVsQXJnTmFtZSA9IGluZmxlY3Rpb24uY2FtZWxpemUodGFibGUucHJvcHMubW9kZWxDbGFzcy5tb2RlbENsYXNzRGF0YSgpLm5hbWUsIHRydWUpXG4gIGNvbnN0IG1vZGVsQ2FsbGJhY2tBcmdzID0gLyoqIEB0eXBlIHtSZWNvcmQ8c3RyaW5nLCBCYXNlTW9kZWwgfCBzdHJpbmc+fSAqLyAoe21vZGVsfSlcblxuICBtb2RlbENhbGxiYWNrQXJnc1ttb2RlbEFyZ05hbWVdID0gbW9kZWxcblxuICByZXR1cm4gbW9kZWxDYWxsYmFja0FyZ3Ncbn1cbiJdfQ==

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

@@ -1,3 +1,140 @@
-declare const _default: any;
+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 TableColumnDefinition = {
+    attribute?: string;
+    columnProps?: {
+        className?: string;
+        style?: object;
+    };
+    commonProps?: {
+        className?: string;
+    };
+};
+export type TableSettingColumn = {
+    identifier(): string;
+};
+export type TableLike = {
+    columnProps: (column: TableColumnDefinition) => {
+        style?: object;
+    };
+    headerLabelForColumn: (column: TableColumnDefinition) => string;
+    styleForColumn: (args: object) => object;
+};
+export type Props = {
+    animatedPosition: Animated.ValueXY;
+    animatedWidth: Animated.Value;
+    animatedZIndex: Animated.Value;
+    column: TableColumnDefinition;
+    columnIndex: number;
+    even: boolean;
+    events: EventEmitter;
+    model: BaseModel;
+    table: TableLike;
+    tableSettingColumn: TableSettingColumn;
+};
+export type State = Record<string, never>;
+import React from "react";
+import { Animated } from "react-native";
+import { EventEmitter } from "eventemitter3";
 //# sourceMappingURL=model-column.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"model-column.d.ts","sourceRoot":"/src/","sources":["table/model-column.jsx"],"names":[],"mappings":""}
+{"version":3,"file":"model-column.d.ts","sourceRoot":"/src/","sources":["table/model-column.jsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA+GwtxB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA7Flz3B;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,WAAW,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC;iCAC5G;IAAC,UAAU,IAAI,MAAM,CAAA;CAAC;;iBAGtB,CAAC,MAAM,EAAE,qBAAqB,KAAK;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC;0BACnD,CAAC,MAAM,EAAE,qBAAqB,KAAK,MAAM;oBACzC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;sBAKxB,QAAQ,CAAC,OAAO;mBAChB,QAAQ,CAAC,KAAK;oBACd,QAAQ,CAAC,KAAK;YACd,qBAAqB;iBACrB,MAAM;UACN,OAAO;YACP,YAAY;WACZ,SAAS;WACT,SAAS;wBACT,kBAAkB;;oBAElB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBArCN,OAAO;yBADP,cAAc;6BAMhB,eAAe"}

package/build/table/model-column.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable implicit-arrow-linebreak, import/no-unresolved, indent, sort-imports */
 import { Animated, View } from "react-native";
 import React, { useMemo } from "react";
-import BaseComponent from "../base-component";
 import classNames from "classnames";
 import Column from "./components/column";
 import ColumnContent from "./column-content";
@@ -11,11 +11,34 @@ import { EventEmitter } from "eventemitter3";
 import PropTypes from "prop-types";
 import propTypesExact from "prop-types-exact";
 import memo from "set-state-compare/build/memo.js";
-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";
 import { useBreakpoint } from "responsive-breakpoints";
 import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
-export default memo(shapeComponent(class ApiMakerTableModelColumn extends BaseComponent {
+/** @typedef {import("../base-model.js").default} BaseModel */
+/** @typedef {{attribute?: string, columnProps?: {className?: string, style?: object}, commonProps?: {className?: string}}} TableColumnDefinition */
+/** @typedef {{identifier(): string}} TableSettingColumn */
+/**
+ * @typedef {object} TableLike
+ * @property {(column: TableColumnDefinition) => {style?: object}} columnProps
+ * @property {(column: TableColumnDefinition) => string} headerLabelForColumn
+ * @property {(args: object) => object} styleForColumn
+ */
+/**
+ * @typedef {object} Props
+ * @property {Animated.ValueXY} animatedPosition
+ * @property {Animated.Value} animatedWidth
+ * @property {Animated.Value} animatedZIndex
+ * @property {TableColumnDefinition} column
+ * @property {number} columnIndex
+ * @property {boolean} even
+ * @property {EventEmitter} events
+ * @property {BaseModel} model
+ * @property {TableLike} table
+ * @property {TableSettingColumn} tableSettingColumn
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableModelColumn extends ShapeComponent {
     static propTypes = propTypesExact({
         animatedPosition: PropTypes.instanceOf(Animated.ValueXY).isRequired,
         animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,
@@ -59,4 +82,4 @@ export default memo(shapeComponent(class ApiMakerTableModelColumn extends BaseCo
         return classNames;
     }
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-column.js","sourceRoot":"/src/","sources":["table/model-column.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable implicit-arrow-linebreak, import/no-unresolved, indent, sort-imports */\nimport {Animated, View} from \"react-native\"\nimport React, {useMemo} from \"react\"\nimport BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport Column from \"./components/column\"\nimport ColumnContent from \"./column-content\"\nimport columnIdentifier from \"./column-identifier.js\"\nimport {EventEmitter} from \"eventemitter3\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Text from \"../utils/text\"\nimport {useBreakpoint} from \"responsive-breakpoints\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\n\nexport default memo(shapeComponent(class ApiMakerTableModelColumn extends BaseComponent {\n  static propTypes = propTypesExact({\n    animatedPosition: PropTypes.instanceOf(Animated.ValueXY).isRequired,\n    animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,\n    animatedZIndex: PropTypes.instanceOf(Animated.Value).isRequired,\n    column: PropTypes.object.isRequired,\n    columnIndex: PropTypes.number.isRequired,\n    even: PropTypes.bool.isRequired,\n    events: PropTypes.instanceOf(EventEmitter).isRequired,\n    model: PropTypes.object.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingColumn: PropTypes.object.isRequired\n  })\n\n  render() {\n    const {l, t} = useI18n({namespace: \"js.api_maker.table.model_column\"})\n    const {mdUp} = useBreakpoint()\n    const {animatedWidth, animatedZIndex, column, columnIndex, even, model, table} = this.props\n    const columnProps = table.columnProps(column)\n    const {style, ...restColumnProps} = columnProps\n    const actualStyle = useMemo(() =>\n      Object.assign(\n        table.styleForColumn({\n          column,\n          columnIndex,\n          even,\n          style: {\n            zIndex: animatedZIndex,\n            transform: this.p.animatedPosition.getTranslateTransform(),\n            width: mdUp ? animatedWidth : \"100%\"\n          }\n        }),\n        style\n      ),\n      [column, columnIndex, even, animatedZIndex, mdUp, animatedWidth, style]\n    )\n\n    const className = classNames(this.columnClassNamesForColumn(column))\n    const identifier = columnIdentifier(column)\n    const dataSet = useMemo(() => ({class: className, identifier}), [className])\n\n    return (\n      <Column\n        dataSet={dataSet}\n        style={actualStyle}\n        {...restColumnProps}\n      >\n        {!mdUp &&\n          <View dataSet={this.cache(\"columnLabelDataSet\", {class: \"table--column-label\"})}>\n            <Text style={this.cache(\"columnLabelTextStyle\", {fontWeight: \"bold\"})}>\n              {table.headerLabelForColumn(column)}\n            </Text>\n          </View>\n        }\n        <View dataSet={this.cache(\"columnValueDataSet\", {class: \"table--column-value\"})}>\n          {new ColumnContent({column, l, model, t, table}).content()}\n        </View>\n      </Column>\n    )\n  }\n\n  columnClassNamesForColumn(column) {\n    const classNames = [\"table--column\"]\n\n    if (column.commonProps && column.commonProps.className) classNames.push(column.commonProps.className)\n    if (column.columnProps && column.columnProps.className) classNames.push(column.columnProps.className)\n\n    return classNames\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-column.js","sourceRoot":"/src/","sources":["table/model-column.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable implicit-arrow-linebreak, import/no-unresolved, indent, sort-imports */\nimport {Animated, View} from \"react-native\"\nimport React, {useMemo} from \"react\"\nimport classNames from \"classnames\"\nimport Column from \"./components/column\"\nimport ColumnContent from \"./column-content\"\nimport columnIdentifier from \"./column-identifier.js\"\nimport {EventEmitter} from \"eventemitter3\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Text from \"../utils/text\"\nimport {useBreakpoint} from \"responsive-breakpoints\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\n\n/** @typedef {import(\"../base-model.js\").default} BaseModel */\n/** @typedef {{attribute?: string, columnProps?: {className?: string, style?: object}, commonProps?: {className?: string}}} TableColumnDefinition */\n/** @typedef {{identifier(): string}} TableSettingColumn */\n/**\n * @typedef {object} TableLike\n * @property {(column: TableColumnDefinition) => {style?: object}} columnProps\n * @property {(column: TableColumnDefinition) => string} headerLabelForColumn\n * @property {(args: object) => object} styleForColumn\n */\n\n/**\n * @typedef {object} Props\n * @property {Animated.ValueXY} animatedPosition\n * @property {Animated.Value} animatedWidth\n * @property {Animated.Value} animatedZIndex\n * @property {TableColumnDefinition} column\n * @property {number} columnIndex\n * @property {boolean} even\n * @property {EventEmitter} events\n * @property {BaseModel} model\n * @property {TableLike} table\n * @property {TableSettingColumn} tableSettingColumn\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableModelColumn extends ShapeComponent {\n  static propTypes = propTypesExact({\n    animatedPosition: PropTypes.instanceOf(Animated.ValueXY).isRequired,\n    animatedWidth: PropTypes.instanceOf(Animated.Value).isRequired,\n    animatedZIndex: PropTypes.instanceOf(Animated.Value).isRequired,\n    column: PropTypes.object.isRequired,\n    columnIndex: PropTypes.number.isRequired,\n    even: PropTypes.bool.isRequired,\n    events: PropTypes.instanceOf(EventEmitter).isRequired,\n    model: PropTypes.object.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingColumn: PropTypes.object.isRequired\n  })\n\n  render() {\n    const {l, t} = useI18n({namespace: \"js.api_maker.table.model_column\"})\n    const {mdUp} = useBreakpoint()\n    const {animatedWidth, animatedZIndex, column, columnIndex, even, model, table} = this.props\n    const columnProps = table.columnProps(column)\n    const {style, ...restColumnProps} = columnProps\n    const actualStyle = useMemo(() =>\n      Object.assign(\n        table.styleForColumn({\n          column,\n          columnIndex,\n          even,\n          style: {\n            zIndex: animatedZIndex,\n            transform: this.p.animatedPosition.getTranslateTransform(),\n            width: mdUp ? animatedWidth : \"100%\"\n          }\n        }),\n        style\n      ),\n      [column, columnIndex, even, animatedZIndex, mdUp, animatedWidth, style]\n    )\n\n    const className = classNames(this.columnClassNamesForColumn(column))\n    const identifier = columnIdentifier(column)\n    const dataSet = useMemo(() => ({class: className, identifier}), [className])\n\n    return (\n      <Column\n        dataSet={dataSet}\n        style={actualStyle}\n        {...restColumnProps}\n      >\n        {!mdUp &&\n          <View dataSet={this.cache(\"columnLabelDataSet\", {class: \"table--column-label\"})}>\n            <Text style={this.cache(\"columnLabelTextStyle\", {fontWeight: \"bold\"})}>\n              {table.headerLabelForColumn(column)}\n            </Text>\n          </View>\n        }\n        <View dataSet={this.cache(\"columnValueDataSet\", {class: \"table--column-value\"})}>\n          {new ColumnContent({column, l, model, t, table}).content()}\n        </View>\n      </Column>\n    )\n  }\n\n  columnClassNamesForColumn(column) {\n    const classNames = [\"table--column\"]\n\n    if (column.commonProps && column.commonProps.className) classNames.push(column.commonProps.className)\n    if (column.columnProps && column.columnProps.className) classNames.push(column.columnProps.className)\n\n    return classNames\n  }\n}))\n"]}

package/build/table/model-row.d.ts

@@ -1,3 +1,23 @@
-declare const _default: any;
+declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type PreparedColumn = {
+    animatedPosition: import("react-native").Animated.ValueXY;
+    animatedWidth: import("react-native").Animated.Value;
+    animatedZIndex: import("react-native").Animated.Value;
+    column: object;
+    tableSettingColumn: object;
+};
+export type Props = {
+    cacheKey: string;
+    columns?: PreparedColumn[];
+    columnWidths: object;
+    events: EventEmitter;
+    index: number;
+    model: object;
+    table: object;
+    tableSettingFullCacheKey: string;
+};
+export type State = Record<string, never>;
+import React from "react";
+import { EventEmitter } from "eventemitter3";
 //# sourceMappingURL=model-row.d.ts.map

package/build/table/model-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-row.d.ts","sourceRoot":"/src/","sources":["table/model-row.jsx"],"names":[],"mappings":""}
+{"version":3,"file":"model-row.d.ts","sourceRoot":"/src/","sources":["table/model-row.jsx"],"names":[],"mappings":";;;sBAuBc,OAAO,cAAc,EAAE,QAAQ,CAAC,OAAO;mBACvC,OAAO,cAAc,EAAE,QAAQ,CAAC,KAAK;oBACrC,OAAO,cAAc,EAAE,QAAQ,CAAC,KAAK;YACrC,MAAM;wBACN,MAAM;;;cAKN,MAAM;cACN,cAAc,EAAE;kBAChB,MAAM;YACN,YAAY;WACZ,MAAM;WACN,MAAM;WACN,MAAM;8BACN,MAAM;;oBAEN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBA3BjB,OAAO;6BATE,eAAe"}

package/build/table/model-row.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable implicit-arrow-linebreak, max-len, react/jsx-sort-props, sort-imports */
 import { Pressable } from "react-native";
-import BaseComponent from "../base-component";
 import Column from "./components/column";
 import columnIdentifier from "./column-identifier.js";
 import { EventEmitter } from "eventemitter3";
@@ -16,10 +16,30 @@ import propTypesExact from "prop-types-exact";
 import React from "react";
 import Row from "./components/row";
 import memo from "set-state-compare/build/memo.js";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
 import WorkerPluginsCheckbox from "./worker-plugins-checkbox";
-export default memo(shapeComponent(class ApiMakerBootStrapLiveTableModelRow extends BaseComponent {
+/**
+ * @typedef {object} PreparedColumn
+ * @property {import("react-native").Animated.ValueXY} animatedPosition
+ * @property {import("react-native").Animated.Value} animatedWidth
+ * @property {import("react-native").Animated.Value} animatedZIndex
+ * @property {object} column
+ * @property {object} tableSettingColumn
+ */
+/**
+ * @typedef {object} Props
+ * @property {string} cacheKey
+ * @property {PreparedColumn[]} [columns]
+ * @property {object} columnWidths
+ * @property {EventEmitter} events
+ * @property {number} index
+ * @property {object} model
+ * @property {object} table
+ * @property {string} tableSettingFullCacheKey
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerBootStrapLiveTableModelRow extends ShapeComponent {
     static propTypes = propTypesExact({
         cacheKey: PropTypes.string.isRequired,
         columns: PropTypes.array,
@@ -78,4 +98,4 @@ export default memo(shapeComponent(class ApiMakerBootStrapLiveTableModelRow exte
         }
     };
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-row.js","sourceRoot":"/src/","sources":["table/model-row.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable implicit-arrow-linebreak, max-len, react/jsx-sort-props, sort-imports */\nimport {Pressable} from \"react-native\"\nimport BaseComponent from \"../base-component\"\nimport Column from \"./components/column\"\nimport columnIdentifier from \"./column-identifier.js\"\nimport {EventEmitter} from \"eventemitter3\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport Icon from \"../utils/icon\"\nimport * as inflection from \"inflection\"\nimport modelCallbackArgs from \"./model-callback-args.js\"\nimport Link from \"../link\"\nimport ModelColumn from \"./model-column\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport React from \"react\"\nimport Row from \"./components/row\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport WorkerPluginsCheckbox from \"./worker-plugins-checkbox\"\n\nexport default memo(shapeComponent(class ApiMakerBootStrapLiveTableModelRow extends BaseComponent {\n  static propTypes = propTypesExact({\n    cacheKey: PropTypes.string.isRequired,\n    columns: PropTypes.array,\n    columnWidths: PropTypes.object.isRequired,\n    events: PropTypes.instanceOf(EventEmitter).isRequired,\n    index: PropTypes.number.isRequired,\n    model: PropTypes.object.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingFullCacheKey: PropTypes.string.isRequired\n  })\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.model_row\"})\n\n    this.t = t\n  }\n\n  render() {\n    const {index, table, model} = this.p\n    const {modelClass, workplace} = table.p\n    const {actionsContent, destroyEnabled, editModelPath, viewModelPath} = table.props\n    const {columns, currentWorkplace} = table.state\n    const {styleForColumn, styleForRow} = table.tt\n    const even = index % 2 == 0\n\n    this.modelCallbackArgs = modelCallbackArgs(table, model) // 'model' can change so this needs to be re-cached for every render\n\n    let editPath, viewPath\n\n    if (editModelPath && model.can(\"edit\")) {\n      editPath = editModelPath(this.modelCallbackArgs)\n    }\n\n    if (viewModelPath && model.can(\"show\")) {\n      viewPath = viewModelPath(this.modelCallbackArgs)\n    }\n\n    return (\n      <Row\n        dataSet={this.cache(\"rowDataSet\", {class: `${inflection.dasherize(modelClass.modelClassData().paramKey)}-row`, modelId: model.id()}, [model.id(), modelClass.modelClassData().paramKey])}\n        style={styleForRow({even})}\n      >\n        {workplace &&\n          <Column dataSet={this.cache(\"columnDataSet\", {class: \"workplace-column\"})} style={styleForColumn({even, style: {width: 41}})}>\n            <WorkerPluginsCheckbox\n              currentWorkplace={currentWorkplace}\n              model={model}\n              style={this.cache(\"workerPluginsCheckboxStyle\", {marginHorizontal: \"auto\"})}\n            />\n          </Column>\n        }\n        {columns && this.columnsContentFromColumns(model, even)}\n        <Column dataSet={this.cache(\"actionsColumnDataSet\", {class: \"actions-column\"})} style={styleForColumn({even, style: {}, type: \"actions\"})}>\n          {actionsContent && actionsContent(this.tt.modelCallbackArgs)}\n          {viewPath &&\n            <Link dataSet={this.cache(\"viewButtonDataSet\", {class: \"view-button\"})} style={this.cache(\"searchLinkStyle\", {marginLeft: 2, marginRight: 2})} to={viewPath}>\n              <Icon name=\"search\" size={18} />\n            </Link>\n          }\n          {editPath &&\n            <Link dataSet={this.cache(\"editButtonDataSet\", {class: \"edit-button\"})} style={this.cache(\"editButtonStyle\", {marginLeft: 2, marginRight: 2})} to={editPath}>\n              <Icon name=\"pencil\" size={20} />\n            </Link>\n          }\n          {destroyEnabled && model.can(\"destroy\") &&\n            <Pressable\n              dataSet={this.cache(\"destroyButtonDataSet\", {class: \"destroy-button\"})}\n              style={this.cache(\"destroyButtonStyle\", {marginLeft: 2, marginRight: 2})}\n              onPress={this.tt.onDestroyClicked}\n            >\n              <Icon name=\"remove\" size={22} />\n            </Pressable>\n          }\n        </Column>\n      </Row>\n    )\n  }\n\n  columnsContentFromColumns(model, even) {\n    const {columns, events, table} = this.p\n\n    return columns?.map(({animatedPosition, animatedWidth, animatedZIndex, column, tableSettingColumn}, columnIndex) =>\n      <ModelColumn\n        animatedPosition={animatedPosition}\n        animatedWidth={animatedWidth}\n        animatedZIndex={animatedZIndex}\n        column={column}\n        columnIndex={columnIndex}\n        even={even}\n        events={events}\n        key={columnIdentifier(column)}\n        model={model}\n        table={table}\n        tableSettingColumn={tableSettingColumn}\n      />\n    )\n  }\n\n  onDestroyClicked = async () => {\n    const {t} = this.tt\n    const {destroyMessage} = this.p.table.props\n    const {model} = this.p\n\n    // eslint-disable-next-line no-alert\n    if (!confirm(t(\"js.shared.are_you_sure\"))) {\n      return\n    }\n\n    try {\n      await model.destroy()\n\n      if (destroyMessage) {\n        FlashNotifications.success(destroyMessage)\n      }\n    } catch (error) {\n      FlashNotifications.errorResponse(error)\n    }\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-row.js","sourceRoot":"/src/","sources":["table/model-row.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable implicit-arrow-linebreak, max-len, react/jsx-sort-props, sort-imports */\nimport {Pressable} from \"react-native\"\nimport Column from \"./components/column\"\nimport columnIdentifier from \"./column-identifier.js\"\nimport {EventEmitter} from \"eventemitter3\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport Icon from \"../utils/icon\"\nimport * as inflection from \"inflection\"\nimport modelCallbackArgs from \"./model-callback-args.js\"\nimport Link from \"../link\"\nimport ModelColumn from \"./model-column\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport React from \"react\"\nimport Row from \"./components/row\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport WorkerPluginsCheckbox from \"./worker-plugins-checkbox\"\n\n/**\n * @typedef {object} PreparedColumn\n * @property {import(\"react-native\").Animated.ValueXY} animatedPosition\n * @property {import(\"react-native\").Animated.Value} animatedWidth\n * @property {import(\"react-native\").Animated.Value} animatedZIndex\n * @property {object} column\n * @property {object} tableSettingColumn\n */\n\n/**\n * @typedef {object} Props\n * @property {string} cacheKey\n * @property {PreparedColumn[]} [columns]\n * @property {object} columnWidths\n * @property {EventEmitter} events\n * @property {number} index\n * @property {object} model\n * @property {object} table\n * @property {string} tableSettingFullCacheKey\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerBootStrapLiveTableModelRow extends ShapeComponent {\n  static propTypes = propTypesExact({\n    cacheKey: PropTypes.string.isRequired,\n    columns: PropTypes.array,\n    columnWidths: PropTypes.object.isRequired,\n    events: PropTypes.instanceOf(EventEmitter).isRequired,\n    index: PropTypes.number.isRequired,\n    model: PropTypes.object.isRequired,\n    table: PropTypes.object.isRequired,\n    tableSettingFullCacheKey: PropTypes.string.isRequired\n  })\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.model_row\"})\n\n    this.t = t\n  }\n\n  render() {\n    const {index, table, model} = this.p\n    const {modelClass, workplace} = table.p\n    const {actionsContent, destroyEnabled, editModelPath, viewModelPath} = table.props\n    const {columns, currentWorkplace} = table.state\n    const {styleForColumn, styleForRow} = table.tt\n    const even = index % 2 == 0\n\n    this.modelCallbackArgs = modelCallbackArgs(table, model) // 'model' can change so this needs to be re-cached for every render\n\n    let editPath, viewPath\n\n    if (editModelPath && model.can(\"edit\")) {\n      editPath = editModelPath(this.modelCallbackArgs)\n    }\n\n    if (viewModelPath && model.can(\"show\")) {\n      viewPath = viewModelPath(this.modelCallbackArgs)\n    }\n\n    return (\n      <Row\n        dataSet={this.cache(\"rowDataSet\", {class: `${inflection.dasherize(modelClass.modelClassData().paramKey)}-row`, modelId: model.id()}, [model.id(), modelClass.modelClassData().paramKey])}\n        style={styleForRow({even})}\n      >\n        {workplace &&\n          <Column dataSet={this.cache(\"columnDataSet\", {class: \"workplace-column\"})} style={styleForColumn({even, style: {width: 41}})}>\n            <WorkerPluginsCheckbox\n              currentWorkplace={currentWorkplace}\n              model={model}\n              style={this.cache(\"workerPluginsCheckboxStyle\", {marginHorizontal: \"auto\"})}\n            />\n          </Column>\n        }\n        {columns && this.columnsContentFromColumns(model, even)}\n        <Column dataSet={this.cache(\"actionsColumnDataSet\", {class: \"actions-column\"})} style={styleForColumn({even, style: {}, type: \"actions\"})}>\n          {actionsContent && actionsContent(this.tt.modelCallbackArgs)}\n          {viewPath &&\n            <Link dataSet={this.cache(\"viewButtonDataSet\", {class: \"view-button\"})} style={this.cache(\"searchLinkStyle\", {marginLeft: 2, marginRight: 2})} to={viewPath}>\n              <Icon name=\"search\" size={18} />\n            </Link>\n          }\n          {editPath &&\n            <Link dataSet={this.cache(\"editButtonDataSet\", {class: \"edit-button\"})} style={this.cache(\"editButtonStyle\", {marginLeft: 2, marginRight: 2})} to={editPath}>\n              <Icon name=\"pencil\" size={20} />\n            </Link>\n          }\n          {destroyEnabled && model.can(\"destroy\") &&\n            <Pressable\n              dataSet={this.cache(\"destroyButtonDataSet\", {class: \"destroy-button\"})}\n              style={this.cache(\"destroyButtonStyle\", {marginLeft: 2, marginRight: 2})}\n              onPress={this.tt.onDestroyClicked}\n            >\n              <Icon name=\"remove\" size={22} />\n            </Pressable>\n          }\n        </Column>\n      </Row>\n    )\n  }\n\n  columnsContentFromColumns(model, even) {\n    const {columns, events, table} = this.p\n\n    return columns?.map(({animatedPosition, animatedWidth, animatedZIndex, column, tableSettingColumn}, columnIndex) =>\n      <ModelColumn\n        animatedPosition={animatedPosition}\n        animatedWidth={animatedWidth}\n        animatedZIndex={animatedZIndex}\n        column={column}\n        columnIndex={columnIndex}\n        even={even}\n        events={events}\n        key={columnIdentifier(column)}\n        model={model}\n        table={table}\n        tableSettingColumn={tableSettingColumn}\n      />\n    )\n  }\n\n  onDestroyClicked = async () => {\n    const {t} = this.tt\n    const {destroyMessage} = this.p.table.props\n    const {model} = this.p\n\n    // eslint-disable-next-line no-alert\n    if (!confirm(t(\"js.shared.are_you_sure\"))) {\n      return\n    }\n\n    try {\n      await model.destroy()\n\n      if (destroyMessage) {\n        FlashNotifications.success(destroyMessage)\n      }\n    } catch (error) {\n      FlashNotifications.errorResponse(error)\n    }\n  }\n}))\n"]}

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

@@ -1,3 +1,38 @@
-/** selectCalculator. */
-export default function selectCalculator(...props: any[]): any;
+/**
+ * Calculates the backend select payload for the current table render.
+ * @param {{table: SelectTable}} props
+ * @returns {SelectMap}
+ */
+export default function selectCalculator(props: {
+    table: SelectTable;
+}): SelectMap;
+export type ModelRelationship = {
+    name: string;
+    resource_name: string;
+};
+export type SelectColumnDefinition = {
+    attribute?: string;
+    path?: string[];
+};
+export type PreparedColumn = {
+    column: SelectColumnDefinition;
+};
+export type SelectMap = Record<string, string[]>;
+export type SelectModelClass = {
+    hasAttribute: (attributeName: string) => boolean;
+    modelClassData: () => {
+        name: string;
+        relationships: ModelRelationship[];
+    };
+    primaryKey: () => string;
+};
+export type SelectTable = {
+    props: {
+        modelClass: SelectModelClass;
+        select?: SelectMap;
+    };
+    state: {
+        preparedColumns: PreparedColumn[];
+    };
+};
 //# sourceMappingURL=select-calculator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"select-calculator.d.ts","sourceRoot":"/src/","sources":["table/select-calculator.js"],"names":[],"mappings":"AAkEA,wBAAwB;AACxB,+DAEC"}
+{"version":3,"file":"select-calculator.d.ts","sourceRoot":"/src/","sources":["table/select-calculator.js"],"names":[],"mappings":"AAsFA;;;;GAIG;AACH,gDAHW;IAAC,KAAK,EAAE,WAAW,CAAA;CAAC,GAClB,SAAS,CAIrB;gCAvFa;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC;qCACrC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC;6BACrC;IAAC,MAAM,EAAE,sBAAsB,CAAA;CAAC;wBAChC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;;kBAGxB,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO;oBAClC,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,iBAAiB,EAAE,CAAA;KAAC;gBACxD,MAAM,MAAM;;0BAEZ;IAAC,KAAK,EAAE;QAAC,UAAU,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAC,CAAC;IAAC,KAAK,EAAE;QAAC,eAAe,EAAE,cAAc,EAAE,CAAA;KAAC,CAAA;CAAC"}