@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/table/filters/index.d.ts

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

package/build/table/filters/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"/src/","sources":["table/filters/index.jsx"],"names":[],"mappings":";;kBAckB,OAAO"}
+{"version":3,"file":"index.d.ts","sourceRoot":"/src/","sources":["table/filters/index.jsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAgM04sB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA5Kp+yB,SAAS,GAAG;IAAC,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC;IAAC,cAAc,IAAI;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC;+BACrE,SAAS,GAAG;IAAC,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC;IAAC,IAAI,IAAI,MAAM,CAAC;IAAC,WAAW,IAAI,MAAM,EAAE,CAAC;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC;+BACtG;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;;kBAI7F,gBAAgB;gBAChB,cAAc,qBAAqB,EAAE,OAAO;eAC5C,MAAM;gBACN,MAAM;;;YAIN,gBAAgB,GAAG,SAAS;yBAC5B,OAAO,GAAG,SAAS;yBACnB,KAAK,GAAG,gBAAgB,GAAG,SAAS;;kBArBhC,OAAO"}

package/build/table/filters/index.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable implicit-arrow-linebreak, import/no-unresolved, max-len, react/button-has-type, react/jsx-sort-props, react/no-array-index-key, sort-imports */
-import BaseComponent from "../../base-component";
 import { digg, digs } from "diggerize";
 import Filter from "./filter";
 import FilterForm from "./filter-form";
@@ -12,12 +12,29 @@ import PropTypes from "prop-types";
 // @ts-expect-error Runtime-resolved module
 import { TableSearch } from "models.js";
 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 React from "react";
 import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
 import useQueryParams from "on-location-changed/build/use-query-params.js";
 import { View } from "react-native";
-export default memo(shapeComponent(class ApiMakerTableFilters extends BaseComponent {
+/** @typedef {import("../../base-model.js").default} BaseModel */
+/** @typedef {BaseModel & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */
+/** @typedef {BaseModel & {id(): number | string, name(): string, queryParams(): object[], destroy(): Promise<void>}} TableSearchModel */
+/** @typedef {{filterIndex: number} & Record<string, object | string | number | boolean | null | undefined>} TableFilterDraft */
+/**
+ * @typedef {object} Props
+ * @property {CurrentUserModel} [currentUser]
+ * @property {typeof import("../../base-model.js").default} modelClass
+ * @property {string} queryName
+ * @property {string} querySName
+ */
+/**
+ * @typedef {object} State
+ * @property {TableFilterDraft | undefined} filter
+ * @property {boolean | undefined} showLoadSearchModal
+ * @property {false | TableSearchModel | undefined} showSaveSearchModal
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFilters extends ShapeComponent {
     static propTypes = {
         currentUser: PropTypes.object,
         modelClass: PropTypes.func.isRequired,
@@ -98,4 +115,4 @@ export default memo(shapeComponent(class ApiMakerTableFilters extends BaseCompon
     };
     hasAnyFilters = () => Object.keys(this.currentFilters()).length > 0;
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/src/","sources":["table/filters/index.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable implicit-arrow-linebreak, import/no-unresolved, max-len, react/button-has-type, react/jsx-sort-props, react/no-array-index-key, sort-imports */\nimport BaseComponent from \"../../base-component\"\nimport {digg, digs} from \"diggerize\"\nimport Filter from \"./filter\"\nimport FilterForm from \"./filter-form\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport LoadSearchModal from \"./load-search-modal\"\nimport SaveSearchModal from \"./save-search-modal\"\nimport Params from \"../../params.js\"\nimport PropTypes from \"prop-types\"\n// @ts-expect-error Runtime-resolved module\nimport {TableSearch} from \"models.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport React from \"react\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport {View} from \"react-native\"\n\nexport default memo(shapeComponent(class ApiMakerTableFilters extends BaseComponent {\n  static propTypes = {\n    currentUser: PropTypes.object,\n    modelClass: PropTypes.func.isRequired,\n    queryName: PropTypes.string.isRequired,\n    querySName: PropTypes.string.isRequired\n  }\n\n  state = {\n    filter: undefined,\n    showLoadSearchModal: undefined,\n    showSaveSearchModal: false\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters\"})\n\n    this.queryParams = useQueryParams()\n    this.t = t\n  }\n\n  render() {\n    const {modelClass, querySName} = digs(this.props, \"modelClass\", \"querySName\")\n    const {currentUser} = this.props\n    const {filter, showLoadSearchModal, showSaveSearchModal} = digs(this.state, \"filter\", \"showLoadSearchModal\", \"showSaveSearchModal\")\n    const currentFilters = this.currentFilters()\n\n    return (\n      <View dataSet={this.cache(\"rootViewDataSet\", {class: \"api-maker--table--filters\"})} style={this.cache(\"rootViewStyle\", {alignItems: \"flex-start\"})}>\n        {filter &&\n          <FilterForm\n            filter={filter}\n            key={`filter-${filter.filterIndex}`}\n            modelClass={modelClass}\n            onApplyClicked={this.tt.onApplyClicked}\n            onRequestClose={this.tt.onFilterFormRequestClose}\n            querySearchName={querySName}\n          />\n        }\n        {showLoadSearchModal &&\n          <LoadSearchModal\n            currentUser={currentUser}\n            modelClass={modelClass}\n            onEditSearchPressed={digg(this, \"onEditSearchPressed\")}\n            onRequestClose={digg(this, \"onRequestCloseLoadSearchModal\")}\n            querySearchName={querySName}\n          />\n        }\n        {showSaveSearchModal &&\n          <SaveSearchModal\n            currentFilters={digg(this, \"currentFilters\")}\n            currentUser={currentUser}\n            onRequestClose={digg(this, \"onRequestCloseSaveSearchModal\")}\n            search={showSaveSearchModal}\n          />\n        }\n        {currentFilters?.map((filterData, filterIndex) =>\n          <Filter\n            key={filterIndex}\n            filterIndex={filterIndex}\n            onClick={this.tt.onFilterClicked}\n            onRemoveClicked={this.tt.onRemoveClicked}\n            {...filterData}\n          />\n        )}\n        <View dataSet={this.cache(\"filterActionsDataSet\", {class: \"filter-actions\"})} style={this.cache(\"filterActionsStyle\", {flexDirection: \"row\", marginTop: 10})}>\n          <button className=\"add-new-filter-button\" onClick={this.tt.onAddFilterClicked}>\n            {this.t(\".add_new_filter\", {defaultValue: \"Add new filter\"})}\n          </button>\n          {currentUser &&\n            <>\n              <button className=\"save-search-button\" onClick={this.tt.onSaveSearchClicked} style={{marginLeft: 10}}>\n                {this.t(\".save_search\", {defaultValue: \"Save search\"})}\n              </button>\n              <button className=\"load-search-button\" onClick={this.tt.onLoadSearchClicked} style={{marginLeft: 10}}>\n                {this.t(\".load_search\", {defaultValue: \"Load search\"})}\n              </button>\n            </>\n          }\n        </View>\n      </View>\n    )\n  }\n\n  currentFilters = () => {\n    const {querySName} = digs(this.props, \"querySName\")\n    const currentFilters = this.queryParams[querySName] || []\n\n    return currentFilters.map((currentFilter) => JSON.parse(currentFilter))\n  }\n\n  onAddFilterClicked = (e) => {\n    e.preventDefault()\n\n    const newFilterIndex = this.currentFilters().length\n\n    this.setState({\n      filter: {\n        filterIndex: newFilterIndex\n      }\n    })\n  }\n\n  onApplyClicked = () => this.setState({filter: undefined})\n\n  onEditSearchPressed = ({search}) => {\n    this.onRequestCloseLoadSearchModal()\n    this.setState({\n      showSaveSearchModal: search\n    })\n  }\n\n  onFilterClicked = (filter) => this.setState({filter})\n  onFilterFormRequestClose = () => this.setState({filter: undefined})\n\n  onLoadSearchClicked = (e) => {\n    e.preventDefault()\n\n    this.setState({\n      showLoadSearchModal: true\n    })\n  }\n\n  onRemoveClicked = ({filterIndex}) => {\n    const {querySName} = digs(this.props, \"querySName\")\n    const searchParams = Params.parse()[querySName] || {}\n\n    delete searchParams[filterIndex]\n\n    const newParams = {}\n\n    newParams[querySName] = searchParams\n\n    Params.changeParams(newParams)\n\n    this.setState({\n      filter: undefined\n    })\n  }\n\n  onRequestCloseLoadSearchModal = () => this.setState({showLoadSearchModal: false})\n  onRequestCloseSaveSearchModal = () => this.setState({showSaveSearchModal: undefined})\n\n  onSaveSearchClicked = (e) => {\n    e.preventDefault()\n\n    if (this.hasAnyFilters()) {\n      this.setState({showSaveSearchModal: new TableSearch()})\n    } else {\n      FlashNotifications.alert(this.t(\".no_filters_has_been_set\", {defaultValue: \"No filters has been set\"}))\n    }\n  }\n\n  hasAnyFilters = () => Object.keys(this.currentFilters()).length > 0\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/src/","sources":["table/filters/index.jsx"],"names":[],"mappings":";AAAA,YAAY;AACZ,iKAAiK;AACjK,OAAO,EAAC,IAAI,EAAE,IAAI,EAAC,MAAM,WAAW,CAAA;AACpC,OAAO,MAAM,MAAM,UAAU,CAAA;AAC7B,OAAO,UAAU,MAAM,eAAe,CAAA;AACtC,OAAO,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAA;AACtD,OAAO,eAAe,MAAM,qBAAqB,CAAA;AACjD,OAAO,eAAe,MAAM,qBAAqB,CAAA;AACjD,OAAO,MAAM,MAAM,iBAAiB,CAAA;AACpC,OAAO,SAAS,MAAM,YAAY,CAAA;AAClC,2CAA2C;AAC3C,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAA;AACrC,OAAO,IAAI,MAAM,iCAAiC,CAAA;AAClD,OAAO,EAAC,cAAc,EAAE,cAAc,EAAC,MAAM,4CAA4C,CAAA;AACzF,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,OAAO,MAAM,wCAAwC,CAAA;AAC5D,OAAO,cAAc,MAAM,+CAA+C,CAAA;AAC1E,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAA;AAEjC,iEAAiE;AACjE,wGAAwG;AACxG,yIAAyI;AACzI,gIAAgI;AAEhI;;;;;;GAMG;AACH;;;;;GAKG;AACH,eAAe,IAAI,CAAC,cAAc,CAAC,+CAA+C,CAAC,MAAM,oBAAqB,SAAQ,cAAc;IAClI,MAAM,CAAC,SAAS,GAAG;QACjB,WAAW,EAAE,SAAS,CAAC,MAAM;QAC7B,UAAU,EAAE,SAAS,CAAC,IAAI,CAAC,UAAU;QACrC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,UAAU;QACtC,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,UAAU;KACxC,CAAA;IAED,KAAK,GAAG;QACN,MAAM,EAAE,SAAS;QACjB,mBAAmB,EAAE,SAAS;QAC9B,mBAAmB,EAAE,KAAK;KAC3B,CAAA;IAED,KAAK;QACH,MAAM,EAAC,CAAC,EAAC,GAAG,OAAO,CAAC,EAAC,SAAS,EAAE,4BAA4B,EAAC,CAAC,CAAA;QAE9D,IAAI,CAAC,WAAW,GAAG,cAAc,EAAE,CAAA;QACnC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACZ,CAAC;IAED,MAAM;QACJ,MAAM,EAAC,UAAU,EAAE,UAAU,EAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,CAAC,CAAA;QAC7E,MAAM,EAAC,WAAW,EAAC,GAAG,IAAI,CAAC,KAAK,CAAA;QAChC,MAAM,EAAC,MAAM,EAAE,mBAAmB,EAAE,mBAAmB,EAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,qBAAqB,CAAC,CAAA;QACnI,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAE5C,OAAO,CACL,MAAC,IAAI,IAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,EAAE,EAAC,KAAK,EAAE,2BAA2B,EAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,EAAC,UAAU,EAAE,YAAY,EAAC,CAAC,aAC/I,MAAM;oBACL,KAAC,UAAU,IACT,MAAM,EAAE,MAAM,EAEd,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC,cAAc,EACtC,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC,wBAAwB,EAChD,eAAe,EAAE,UAAU,IAJtB,UAAU,MAAM,CAAC,WAAW,EAAE,CAKnC,EAEH,mBAAmB;oBAClB,KAAC,eAAe,IACd,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,UAAU,EACtB,mBAAmB,EAAE,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,EACtD,cAAc,EAAE,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,EAC3D,eAAe,EAAE,UAAU,GAC3B,EAEH,mBAAmB;oBAClB,KAAC,eAAe,IACd,cAAc,EAAE,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,EAC5C,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,EAC3D,MAAM,EAAE,mBAAmB,GAC3B,EAEH,cAAc,EAAE,GAAG,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE,CAC/C,KAAC,MAAM,IAEL,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,eAAe,EAChC,eAAe,EAAE,IAAI,CAAC,EAAE,CAAC,eAAe,KACpC,UAAU,IAJT,WAAW,CAKhB,CACH,EACD,MAAC,IAAI,IAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,EAAC,KAAK,EAAE,gBAAgB,EAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAC,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAC,CAAC,aAC1J,iBAAQ,SAAS,EAAC,uBAAuB,EAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,kBAAkB,YAC1E,IAAI,CAAC,CAAC,CAAC,iBAAiB,EAAE,EAAC,YAAY,EAAE,gBAAgB,EAAC,CAAC,GACrD,EACR,WAAW;4BACV,8BACE,iBAAQ,SAAS,EAAC,oBAAoB,EAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,KAAK,EAAE,EAAC,UAAU,EAAE,EAAE,EAAC,YACjG,IAAI,CAAC,CAAC,CAAC,cAAc,EAAE,EAAC,YAAY,EAAE,aAAa,EAAC,CAAC,GAC/C,EACT,iBAAQ,SAAS,EAAC,oBAAoB,EAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,KAAK,EAAE,EAAC,UAAU,EAAE,EAAE,EAAC,YACjG,IAAI,CAAC,CAAC,CAAC,cAAc,EAAE,EAAC,YAAY,EAAE,aAAa,EAAC,CAAC,GAC/C,IACR,IAEA,IACF,CACR,CAAA;IACH,CAAC;IAED,cAAc,GAAG,GAAG,EAAE;QACpB,MAAM,EAAC,UAAU,EAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAA;QACnD,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;QAEzD,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAA;IACzE,CAAC,CAAA;IAED,kBAAkB,GAAG,CAAC,CAAC,EAAE,EAAE;QACzB,CAAC,CAAC,cAAc,EAAE,CAAA;QAElB,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,CAAA;QAEnD,IAAI,CAAC,QAAQ,CAAC;YACZ,MAAM,EAAE;gBACN,WAAW,EAAE,cAAc;aAC5B;SACF,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,cAAc,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAA;IAEzD,mBAAmB,GAAG,CAAC,EAAC,MAAM,EAAC,EAAE,EAAE;QACjC,IAAI,CAAC,6BAA6B,EAAE,CAAA;QACpC,IAAI,CAAC,QAAQ,CAAC;YACZ,mBAAmB,EAAE,MAAM;SAC5B,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,eAAe,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,MAAM,EAAC,CAAC,CAAA;IACrD,wBAAwB,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC,CAAA;IAEnE,mBAAmB,GAAG,CAAC,CAAC,EAAE,EAAE;QAC1B,CAAC,CAAC,cAAc,EAAE,CAAA;QAElB,IAAI,CAAC,QAAQ,CAAC;YACZ,mBAAmB,EAAE,IAAI;SAC1B,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,eAAe,GAAG,CAAC,EAAC,WAAW,EAAC,EAAE,EAAE;QAClC,MAAM,EAAC,UAAU,EAAC,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAA;QACnD,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;QAErD,OAAO,YAAY,CAAC,WAAW,CAAC,CAAA;QAEhC,MAAM,SAAS,GAAG,EAAE,CAAA;QAEpB,SAAS,CAAC,UAAU,CAAC,GAAG,YAAY,CAAA;QAEpC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;QAE9B,IAAI,CAAC,QAAQ,CAAC;YACZ,MAAM,EAAE,SAAS;SAClB,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,6BAA6B,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,mBAAmB,EAAE,KAAK,EAAC,CAAC,CAAA;IACjF,6BAA6B,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,mBAAmB,EAAE,SAAS,EAAC,CAAC,CAAA;IAErF,mBAAmB,GAAG,CAAC,CAAC,EAAE,EAAE;QAC1B,CAAC,CAAC,cAAc,EAAE,CAAA;QAElB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,CAAC,EAAC,mBAAmB,EAAE,IAAI,WAAW,EAAE,EAAC,CAAC,CAAA;QACzD,CAAC;aAAM,CAAC;YACN,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,0BAA0B,EAAE,EAAC,YAAY,EAAE,yBAAyB,EAAC,CAAC,CAAC,CAAA;QACzG,CAAC;IACH,CAAC,CAAA;IAED,aAAa,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAA;CACpE,CAAC,CAAC,CAAA","sourcesContent":["// @ts-check\n/* eslint-disable implicit-arrow-linebreak, import/no-unresolved, max-len, react/button-has-type, react/jsx-sort-props, react/no-array-index-key, sort-imports */\nimport {digg, digs} from \"diggerize\"\nimport Filter from \"./filter\"\nimport FilterForm from \"./filter-form\"\nimport {FlashNotifications} from \"flash-notifications\"\nimport LoadSearchModal from \"./load-search-modal\"\nimport SaveSearchModal from \"./save-search-modal\"\nimport Params from \"../../params.js\"\nimport PropTypes from \"prop-types\"\n// @ts-expect-error Runtime-resolved module\nimport {TableSearch} from \"models.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport React from \"react\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport {View} from \"react-native\"\n\n/** @typedef {import(\"../../base-model.js\").default} BaseModel */\n/** @typedef {BaseModel & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */\n/** @typedef {BaseModel & {id(): number | string, name(): string, queryParams(): object[], destroy(): Promise<void>}} TableSearchModel */\n/** @typedef {{filterIndex: number} & Record<string, object | string | number | boolean | null | undefined>} TableFilterDraft */\n\n/**\n * @typedef {object} Props\n * @property {CurrentUserModel} [currentUser]\n * @property {typeof import(\"../../base-model.js\").default} modelClass\n * @property {string} queryName\n * @property {string} querySName\n */\n/**\n * @typedef {object} State\n * @property {TableFilterDraft | undefined} filter\n * @property {boolean | undefined} showLoadSearchModal\n * @property {false | TableSearchModel | undefined} showSaveSearchModal\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFilters extends ShapeComponent {\n  static propTypes = {\n    currentUser: PropTypes.object,\n    modelClass: PropTypes.func.isRequired,\n    queryName: PropTypes.string.isRequired,\n    querySName: PropTypes.string.isRequired\n  }\n\n  state = {\n    filter: undefined,\n    showLoadSearchModal: undefined,\n    showSaveSearchModal: false\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters\"})\n\n    this.queryParams = useQueryParams()\n    this.t = t\n  }\n\n  render() {\n    const {modelClass, querySName} = digs(this.props, \"modelClass\", \"querySName\")\n    const {currentUser} = this.props\n    const {filter, showLoadSearchModal, showSaveSearchModal} = digs(this.state, \"filter\", \"showLoadSearchModal\", \"showSaveSearchModal\")\n    const currentFilters = this.currentFilters()\n\n    return (\n      <View dataSet={this.cache(\"rootViewDataSet\", {class: \"api-maker--table--filters\"})} style={this.cache(\"rootViewStyle\", {alignItems: \"flex-start\"})}>\n        {filter &&\n          <FilterForm\n            filter={filter}\n            key={`filter-${filter.filterIndex}`}\n            modelClass={modelClass}\n            onApplyClicked={this.tt.onApplyClicked}\n            onRequestClose={this.tt.onFilterFormRequestClose}\n            querySearchName={querySName}\n          />\n        }\n        {showLoadSearchModal &&\n          <LoadSearchModal\n            currentUser={currentUser}\n            modelClass={modelClass}\n            onEditSearchPressed={digg(this, \"onEditSearchPressed\")}\n            onRequestClose={digg(this, \"onRequestCloseLoadSearchModal\")}\n            querySearchName={querySName}\n          />\n        }\n        {showSaveSearchModal &&\n          <SaveSearchModal\n            currentFilters={digg(this, \"currentFilters\")}\n            currentUser={currentUser}\n            onRequestClose={digg(this, \"onRequestCloseSaveSearchModal\")}\n            search={showSaveSearchModal}\n          />\n        }\n        {currentFilters?.map((filterData, filterIndex) =>\n          <Filter\n            key={filterIndex}\n            filterIndex={filterIndex}\n            onClick={this.tt.onFilterClicked}\n            onRemoveClicked={this.tt.onRemoveClicked}\n            {...filterData}\n          />\n        )}\n        <View dataSet={this.cache(\"filterActionsDataSet\", {class: \"filter-actions\"})} style={this.cache(\"filterActionsStyle\", {flexDirection: \"row\", marginTop: 10})}>\n          <button className=\"add-new-filter-button\" onClick={this.tt.onAddFilterClicked}>\n            {this.t(\".add_new_filter\", {defaultValue: \"Add new filter\"})}\n          </button>\n          {currentUser &&\n            <>\n              <button className=\"save-search-button\" onClick={this.tt.onSaveSearchClicked} style={{marginLeft: 10}}>\n                {this.t(\".save_search\", {defaultValue: \"Save search\"})}\n              </button>\n              <button className=\"load-search-button\" onClick={this.tt.onLoadSearchClicked} style={{marginLeft: 10}}>\n                {this.t(\".load_search\", {defaultValue: \"Load search\"})}\n              </button>\n            </>\n          }\n        </View>\n      </View>\n    )\n  }\n\n  currentFilters = () => {\n    const {querySName} = digs(this.props, \"querySName\")\n    const currentFilters = this.queryParams[querySName] || []\n\n    return currentFilters.map((currentFilter) => JSON.parse(currentFilter))\n  }\n\n  onAddFilterClicked = (e) => {\n    e.preventDefault()\n\n    const newFilterIndex = this.currentFilters().length\n\n    this.setState({\n      filter: {\n        filterIndex: newFilterIndex\n      }\n    })\n  }\n\n  onApplyClicked = () => this.setState({filter: undefined})\n\n  onEditSearchPressed = ({search}) => {\n    this.onRequestCloseLoadSearchModal()\n    this.setState({\n      showSaveSearchModal: search\n    })\n  }\n\n  onFilterClicked = (filter) => this.setState({filter})\n  onFilterFormRequestClose = () => this.setState({filter: undefined})\n\n  onLoadSearchClicked = (e) => {\n    e.preventDefault()\n\n    this.setState({\n      showLoadSearchModal: true\n    })\n  }\n\n  onRemoveClicked = ({filterIndex}) => {\n    const {querySName} = digs(this.props, \"querySName\")\n    const searchParams = Params.parse()[querySName] || {}\n\n    delete searchParams[filterIndex]\n\n    const newParams = {}\n\n    newParams[querySName] = searchParams\n\n    Params.changeParams(newParams)\n\n    this.setState({\n      filter: undefined\n    })\n  }\n\n  onRequestCloseLoadSearchModal = () => this.setState({showLoadSearchModal: false})\n  onRequestCloseSaveSearchModal = () => this.setState({showSaveSearchModal: undefined})\n\n  onSaveSearchClicked = (e) => {\n    e.preventDefault()\n\n    if (this.hasAnyFilters()) {\n      this.setState({showSaveSearchModal: new TableSearch()})\n    } else {\n      FlashNotifications.alert(this.t(\".no_filters_has_been_set\", {defaultValue: \"No filters has been set\"}))\n    }\n  }\n\n  hasAnyFilters = () => Object.keys(this.currentFilters()).length > 0\n}))\n"]}

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

@@ -1,4 +1,134 @@
 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.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 CurrentUserModel = BaseModel & {
+    id(): number | string;
+    modelClassData(): {
+        name: string;
+    };
+};
+export type TableSearchModel = BaseModel & {
+    destroy(): Promise<void>;
+    id(): number | string;
+    name(): string;
+    queryParams(): object[];
+};
+export type SearchLinkProps = {
+    onClick: Function;
+    onDeleted: Function;
+    onEditPressed: Function;
+    search: TableSearch;
+};
+export type SearchLinkState = Record<string, never>;
+export type Props = {
+    className?: string;
+    currentUser: CurrentUserModel;
+    onEditSearchPressed: Function;
+    onRequestClose: Function;
+    querySearchName: string;
+};
+export type State = {
+    searches: TableSearch[] | undefined;
+};
 import React from "react";
 //# sourceMappingURL=load-search-modal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"load-search-modal.d.ts","sourceRoot":"/src/","sources":["table/filters/load-search-modal.jsx"],"names":[],"mappings":";;kBAE6B,OAAO"}
+{"version":3,"file":"load-search-modal.d.ts","sourceRoot":"/src/","sources":["table/filters/load-search-modal.jsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwLmnuB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAvK7s0B,SAAS,GAAG;IAAC,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC;IAAC,cAAc,IAAI;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC;+BACrE,SAAS,GAAG;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,EAAE,IAAI,MAAM,GAAG,MAAM,CAAC;IAAC,IAAI,IAAI,MAAM,CAAC;IAAC,WAAW,IAAI,MAAM,EAAE,CAAA;CAAC;;;;;YAOtG,WAAW;;8BAEX,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;gBA+ErB,MAAM;iBACN,gBAAgB;;;qBAGhB,MAAM;;;cAIN,WAAW,EAAE,GAAC,SAAS;;kBA/GR,OAAO"}

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

@@ -1,20 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable import/no-unresolved, implicit-arrow-linebreak, no-alert */
 /* eslint-disable react/jsx-max-depth, react/jsx-no-literals, sort-imports */
 import React, { useMemo } from "react";
 import { Pressable, View } from "react-native";
-import BaseComponent from "../../base-component";
 import classNames from "classnames";
 import { digg } from "diggerize";
 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 Params from "../../params.js";
 // @ts-expect-error Runtime-resolved module
 import { TableSearch } from "models.js";
 import Text from "../../utils/text";
 import useI18n from "i18n-on-steroids/build/src/use-i18n.js";
 import apiMakerConfig from "../../config.js";
-const SearchLink = memo(shapeComponent(class SearchLink extends BaseComponent {
+/** @typedef {import("../../base-model.js").default} BaseModel */
+/** @typedef {BaseModel & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */
+/** @typedef {BaseModel & {destroy(): Promise<void>, id(): number | string, name(): string, queryParams(): object[]}} TableSearchModel */
+/**
+ * @typedef {object} SearchLinkProps
+ * @property {Function} onClick
+ * @property {Function} onDeleted
+ * @property {Function} onEditPressed
+ * @property {TableSearch} search
+ */
+/** @typedef {Record<string, never>} SearchLinkState */
+const SearchLink = memo(shapeComponent(/** @augments {ShapeComponent<SearchLinkProps, SearchLinkState>} */ class SearchLink extends ShapeComponent {
     render() {
         const { search } = this.props;
         return (_jsxs(View, { dataSet: this.cache("rootViewStyle", { class: "search-row", searchId: search.id() }, [search.id()]), style: this.cache("rootViewStyleStyle", { flexDirection: "row", width: "100%" }), children: [_jsx(Pressable, { dataSet: this.cache("loadSearchLinkPressableDataSet", { class: "load-search-link" }), onPress: this.tt.onSearchClicked, style: this.cache("loadSearchLinkPressableStyle", { justifyContent: "center" }), children: _jsx(Text, { children: search.name() }) }), _jsxs(View, { style: this.cache("actionsViewStyle", { flexDirection: "row", marginLeft: "auto" }), children: [_jsx(Pressable, { dataSet: this.cache("editSearchButtonDataSet", { class: "edit-search-button" }), onPress: this.tt.onEditPressed, style: this.cache("editSearchButtonStyle", {
@@ -49,9 +60,20 @@ const SearchLink = memo(shapeComponent(class SearchLink extends BaseComponent {
     onEditPressed = () => this.props.onEditPressed({ search: this.props.search });
     onSearchClicked = () => this.props.onClick({ search: this.props.search });
 }));
-export default memo(shapeComponent(class ApiMakerTableFiltersLoadSearchModal extends BaseComponent {
+/**
+ * @typedef {object} Props
+ * @property {string} [className]
+ * @property {CurrentUserModel} currentUser
+ * @property {Function} onEditSearchPressed
+ * @property {Function} onRequestClose
+ * @property {string} querySearchName
+ */
+/**
+ * @typedef {object} State
+ * @property {TableSearch[]|undefined} searches
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFiltersLoadSearchModal extends ShapeComponent {
     state = {
-        editSearch: undefined,
         searches: undefined
     };
     setup() {
@@ -89,4 +111,4 @@ export default memo(shapeComponent(class ApiMakerTableFiltersLoadSearchModal ext
         });
     };
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-search-modal.js","sourceRoot":"/src/","sources":["table/filters/load-search-modal.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-unresolved, implicit-arrow-linebreak, no-alert */\n/* eslint-disable react/jsx-max-depth, react/jsx-no-literals, sort-imports */\nimport React, {useMemo} from \"react\"\nimport {Pressable, View} from \"react-native\"\nimport BaseComponent from \"../../base-component\"\nimport classNames from \"classnames\"\nimport {digg} from \"diggerize\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Params from \"../../params.js\"\n// @ts-expect-error Runtime-resolved module\nimport {TableSearch} from \"models.js\"\nimport Text from \"../../utils/text\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport apiMakerConfig from \"../../config.js\"\n\nconst SearchLink = memo(shapeComponent(class SearchLink extends BaseComponent {\n  render() {\n    const {search} = this.props\n\n    return (\n      <View\n        dataSet={this.cache(\"rootViewStyle\", {class: \"search-row\", searchId: search.id()}, [search.id()])}\n        style={this.cache(\"rootViewStyleStyle\", {flexDirection: \"row\", width: \"100%\"})}\n      >\n        <Pressable\n          dataSet={this.cache(\"loadSearchLinkPressableDataSet\", {class: \"load-search-link\"})}\n          onPress={this.tt.onSearchClicked}\n          style={this.cache(\"loadSearchLinkPressableStyle\", {justifyContent: \"center\"})}\n        >\n          <Text>\n            {search.name()}\n          </Text>\n        </Pressable>\n        <View style={this.cache(\"actionsViewStyle\", {flexDirection: \"row\", marginLeft: \"auto\"})}>\n          <Pressable\n            dataSet={this.cache(\"editSearchButtonDataSet\", {class: \"edit-search-button\"})}\n            onPress={this.tt.onEditPressed}\n            style={this.cache(\"editSearchButtonStyle\", {\n              alignItems: \"center\",\n              justifyContent: \"center\",\n              width: 25,\n              height: 25,\n              backgroundColor: \"#fff\",\n              border: \"1px solid #007bff\",\n              borderRadius: 5,\n              color: \"#007bff\"\n            })}\n          >\n            <Text>\n              &#x270E;\n            </Text>\n          </Pressable>\n          <Pressable\n            dataSet={this.cache(\"deleteSearchButtonDataSet\", {class: \"delete-search-button\"})}\n            onPress={this.tt.onDeletePressed}\n            style={this.cache(\"deleteSearchButtonStyle\", {\n              alignItems: \"center\",\n              justifyContent: \"center\",\n              marginLeft: 5,\n              width: 25,\n              height: 25,\n              backgroundColor: \"#fff\",\n              border: \"1px solid #dc3545\",\n              borderRadius: 5,\n              color: \"#dc3545\"\n            })}\n          >\n            <Text>\n              &#x2715;\n            </Text>\n          </Pressable>\n        </View>\n      </View>\n    )\n  }\n\n  onDeletePressed = async () => {\n    if (!confirm(\"Are you sure?\")) {\n      return\n    }\n\n    const {search} = this.props\n\n    await search.destroy()\n    this.props.onDeleted({search})\n  }\n\n  onEditPressed = () => this.props.onEditPressed({search: this.props.search})\n  onSearchClicked = () => this.props.onClick({search: this.props.search})\n}))\n\nexport default memo(shapeComponent(class ApiMakerTableFiltersLoadSearchModal extends BaseComponent {\n  state = {\n    editSearch: undefined,\n    searches: undefined\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters.load_search_modal\"})\n\n    this.t = t\n\n    useMemo(() => {\n      this.loadSearches()\n    }, [])\n  }\n\n  loadSearches = async () => {\n    const {currentUser} = this.props\n    const userType = digg(currentUser.modelClassData(), \"name\")\n    const searches = await TableSearch\n      .ransack({user_id_eq: currentUser.id(), user_type_eq: userType})\n      .toArray()\n\n    this.setState({searches})\n  }\n\n  render() {\n    const {t} = this.tt\n    const {className, currentUser, modelClass, onEditSearchPressed, onRequestClose, querySearchName, ...restProps} = this.props\n    const Modal = apiMakerConfig.getModal()\n\n    return (\n      <Modal className={classNames(\"api-maker--table--filters--load-search-modal\", className)} onRequestClose={onRequestClose} {...restProps}>\n        <View>\n          <Text>\n            {t(\".choose_a_search\", {defaultValue: \"Choose a search\"})}\n          </Text>\n        </View>\n        {this.s.searches?.map((search) =>\n          <SearchLink\n            key={search.id()}\n            onClick={this.tt.onSearchClicked}\n            onDeleted={this.tt.onSearchDeleted}\n            onEditPressed={onEditSearchPressed}\n            search={search}\n          />\n        )}\n      </Modal>\n    )\n  }\n\n  onSearchClicked = ({search}) => {\n    const {onRequestClose, querySearchName} = this.props\n    const queryParams = search.queryParams()\n    const newParams = {}\n\n    newParams[querySearchName] = queryParams.map((queryParam) => JSON.stringify(queryParam))\n\n    Params.changeParams(newParams)\n\n    onRequestClose()\n  }\n\n  onSearchDeleted = ({search}) => {\n    this.setState({\n      searches: this.s.searches.filter((existingSearch) => existingSearch.id() != search.id())\n    })\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-search-modal.js","sourceRoot":"/src/","sources":["table/filters/load-search-modal.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable import/no-unresolved, implicit-arrow-linebreak, no-alert */\n/* eslint-disable react/jsx-max-depth, react/jsx-no-literals, sort-imports */\nimport React, {useMemo} from \"react\"\nimport {Pressable, View} from \"react-native\"\nimport classNames from \"classnames\"\nimport {digg} from \"diggerize\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Params from \"../../params.js\"\n// @ts-expect-error Runtime-resolved module\nimport {TableSearch} from \"models.js\"\nimport Text from \"../../utils/text\"\nimport useI18n from \"i18n-on-steroids/build/src/use-i18n.js\"\nimport apiMakerConfig from \"../../config.js\"\n\n/** @typedef {import(\"../../base-model.js\").default} BaseModel */\n/** @typedef {BaseModel & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */\n/** @typedef {BaseModel & {destroy(): Promise<void>, id(): number | string, name(): string, queryParams(): object[]}} TableSearchModel */\n\n/**\n * @typedef {object} SearchLinkProps\n * @property {Function} onClick\n * @property {Function} onDeleted\n * @property {Function} onEditPressed\n * @property {TableSearch} search\n */\n/** @typedef {Record<string, never>} SearchLinkState */\nconst SearchLink = memo(shapeComponent(/** @augments {ShapeComponent<SearchLinkProps, SearchLinkState>} */ class SearchLink extends ShapeComponent {\n  render() {\n    const {search} = this.props\n\n    return (\n      <View\n        dataSet={this.cache(\"rootViewStyle\", {class: \"search-row\", searchId: search.id()}, [search.id()])}\n        style={this.cache(\"rootViewStyleStyle\", {flexDirection: \"row\", width: \"100%\"})}\n      >\n        <Pressable\n          dataSet={this.cache(\"loadSearchLinkPressableDataSet\", {class: \"load-search-link\"})}\n          onPress={this.tt.onSearchClicked}\n          style={this.cache(\"loadSearchLinkPressableStyle\", {justifyContent: \"center\"})}\n        >\n          <Text>\n            {search.name()}\n          </Text>\n        </Pressable>\n        <View style={this.cache(\"actionsViewStyle\", {flexDirection: \"row\", marginLeft: \"auto\"})}>\n          <Pressable\n            dataSet={this.cache(\"editSearchButtonDataSet\", {class: \"edit-search-button\"})}\n            onPress={this.tt.onEditPressed}\n            style={this.cache(\"editSearchButtonStyle\", {\n              alignItems: \"center\",\n              justifyContent: \"center\",\n              width: 25,\n              height: 25,\n              backgroundColor: \"#fff\",\n              border: \"1px solid #007bff\",\n              borderRadius: 5,\n              color: \"#007bff\"\n            })}\n          >\n            <Text>\n              &#x270E;\n            </Text>\n          </Pressable>\n          <Pressable\n            dataSet={this.cache(\"deleteSearchButtonDataSet\", {class: \"delete-search-button\"})}\n            onPress={this.tt.onDeletePressed}\n            style={this.cache(\"deleteSearchButtonStyle\", {\n              alignItems: \"center\",\n              justifyContent: \"center\",\n              marginLeft: 5,\n              width: 25,\n              height: 25,\n              backgroundColor: \"#fff\",\n              border: \"1px solid #dc3545\",\n              borderRadius: 5,\n              color: \"#dc3545\"\n            })}\n          >\n            <Text>\n              &#x2715;\n            </Text>\n          </Pressable>\n        </View>\n      </View>\n    )\n  }\n\n  onDeletePressed = async () => {\n    if (!confirm(\"Are you sure?\")) {\n      return\n    }\n\n    const {search} = this.props\n\n    await search.destroy()\n    this.props.onDeleted({search})\n  }\n\n  onEditPressed = () => this.props.onEditPressed({search: this.props.search})\n  onSearchClicked = () => this.props.onClick({search: this.props.search})\n}))\n\n/**\n * @typedef {object} Props\n * @property {string} [className]\n * @property {CurrentUserModel} currentUser\n * @property {Function} onEditSearchPressed\n * @property {Function} onRequestClose\n * @property {string} querySearchName\n */\n/**\n * @typedef {object} State\n * @property {TableSearch[]|undefined} searches\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerTableFiltersLoadSearchModal extends ShapeComponent {\n  state = {\n    searches: undefined\n  }\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters.load_search_modal\"})\n\n    this.t = t\n\n    useMemo(() => {\n      this.loadSearches()\n    }, [])\n  }\n\n  loadSearches = async () => {\n    const {currentUser} = this.props\n    const userType = digg(currentUser.modelClassData(), \"name\")\n    const searches = await TableSearch\n      .ransack({user_id_eq: currentUser.id(), user_type_eq: userType})\n      .toArray()\n\n    this.setState({searches})\n  }\n\n  render() {\n    const {t} = this.tt\n    const {className, currentUser, modelClass, onEditSearchPressed, onRequestClose, querySearchName, ...restProps} = this.props\n    const Modal = apiMakerConfig.getModal()\n\n    return (\n      <Modal className={classNames(\"api-maker--table--filters--load-search-modal\", className)} onRequestClose={onRequestClose} {...restProps}>\n        <View>\n          <Text>\n            {t(\".choose_a_search\", {defaultValue: \"Choose a search\"})}\n          </Text>\n        </View>\n        {this.s.searches?.map((search) =>\n          <SearchLink\n            key={search.id()}\n            onClick={this.tt.onSearchClicked}\n            onDeleted={this.tt.onSearchDeleted}\n            onEditPressed={onEditSearchPressed}\n            search={search}\n          />\n        )}\n      </Modal>\n    )\n  }\n\n  onSearchClicked = ({search}) => {\n    const {onRequestClose, querySearchName} = this.props\n    const queryParams = search.queryParams()\n    const newParams = {}\n\n    newParams[querySearchName] = queryParams.map((queryParam) => JSON.stringify(queryParam))\n\n    Params.changeParams(newParams)\n\n    onRequestClose()\n  }\n\n  onSearchDeleted = ({search}) => {\n    this.setState({\n      searches: this.s.searches.filter((existingSearch) => existingSearch.id() != search.id())\n    })\n  }\n}))\n"]}

package/build/table/filters/reflection-element.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=reflection-element.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"reflection-element.d.ts","sourceRoot":"/src/","sources":["table/filters/reflection-element.jsx"],"names":[],"mappings":";;kBAMkB,OAAO"}
+{"version":3,"file":"reflection-element.d.ts","sourceRoot":"/src/","sources":["table/filters/reflection-element.jsx"],"names":[],"mappings":";;oBAYc,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;oBACrB,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBAPjB,OAAO"}

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

@@ -1,15 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable new-cap, no-return-assign, sort-imports */
-import BaseComponent from "../../base-component";
 import PropTypes from "prop-types";
 import PropTypesExact from "prop-types-exact";
 import memo from "set-state-compare/build/memo.js";
 import { Pressable } from "react-native";
 import React from "react";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import Text from "../../utils/text";
 const dataSets = {};
-export default memo(shapeComponent(class ReflectionElement extends BaseComponent {
+/** @typedef {Record<string, never>} Props */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ReflectionElement extends ShapeComponent {
     static propTypes = PropTypesExact({
         modelClassName: PropTypes.string.isRequired,
         onClick: PropTypes.func.isRequired,
@@ -26,4 +28,4 @@ export default memo(shapeComponent(class ReflectionElement extends BaseComponent
     }
     onReflectionClicked = () => this.p.onClick({ reflection: this.p.reflection });
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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