@kaspernj/api-maker 1.0.446 → 1.0.447

package/build/table/filters/index.js

@@ -0,0 +1,182 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import BaseComponent from "../../base-component";
+import { digg, digs } from "diggerize";
+import Filter from "./filter";
+import FilterForm from "./filter-form";
+import LoadSearchModal from "./load-search-modal";
+import SaveSearchModal from "./save-search-modal";
+import PropTypes from "prop-types";
+import memo from "set-state-compare/src/memo";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import models from "../../models";
+import useI18n from "i18n-on-steroids/src/use-i18n";
+import useQueryParams from "on-location-changed/src/use-query-params";
+import { View } from "react-native";
+const {
+  TableSearch
+} = models;
+export default memo(shapeComponent(class ApiMakerTableFilters extends BaseComponent {
+  static propTypes = {
+    currentUser: PropTypes.object,
+    modelClass: PropTypes.func.isRequired,
+    queryName: PropTypes.string.isRequired,
+    querySName: PropTypes.string.isRequired
+  };
+  setup() {
+    const {
+      t
+    } = useI18n({
+      namespace: "js.api_maker.table.filters"
+    });
+    this.queryParams = useQueryParams();
+    this.t = t;
+    this.useStates({
+      filter: undefined,
+      showLoadSearchModal: undefined,
+      showSaveSearchModal: false
+    });
+  }
+  render() {
+    const {
+      modelClass,
+      querySName
+    } = digs(this.props, "modelClass", "querySName");
+    const {
+      currentUser
+    } = this.props;
+    const {
+      filter,
+      showLoadSearchModal,
+      showSaveSearchModal
+    } = digs(this.state, "filter", "showLoadSearchModal", "showSaveSearchModal");
+    const currentFilters = this.currentFilters();
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        class: "api-maker--table--filters"
+      },
+      style: {
+        alignItems: "flex-start"
+      }
+    }, filter && /*#__PURE__*/React.createElement(FilterForm, {
+      filter: filter,
+      key: `filter-${filter.filterIndex}`,
+      modelClass: modelClass,
+      onApplyClicked: digg(this, "onApplyClicked"),
+      querySearchName: querySName
+    }), showLoadSearchModal && /*#__PURE__*/React.createElement(LoadSearchModal, {
+      currentUser: currentUser,
+      modelClass: modelClass,
+      onEditSearchPressed: digg(this, "onEditSearchPressed"),
+      onRequestClose: digg(this, "onRequestCloseLoadSearchModal"),
+      querySearchName: querySName
+    }), showSaveSearchModal && /*#__PURE__*/React.createElement(SaveSearchModal, {
+      currentFilters: digg(this, "currentFilters"),
+      currentUser: currentUser,
+      onRequestClose: digg(this, "onRequestCloseSaveSearchModal"),
+      search: showSaveSearchModal
+    }), currentFilters?.map((filterData, filterIndex) => /*#__PURE__*/React.createElement(Filter, _extends({
+      key: filterIndex,
+      filterIndex: filterIndex,
+      onClick: this.tt.onFilterClicked,
+      onRemoveClicked: this.tt.onRemoveClicked
+    }, filterData))), /*#__PURE__*/React.createElement(View, {
+      className: "filter-actions",
+      style: {
+        flexDirection: "row",
+        marginTop: 10
+      }
+    }, /*#__PURE__*/React.createElement("button", {
+      className: "add-new-filter-button",
+      onClick: this.tt.onAddFilterClicked
+    }, this.t(".add_new_filter", {
+      defaultValue: "Add new filter"
+    })), currentUser && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("button", {
+      className: "save-search-button",
+      onClick: this.tt.onSaveSearchClicked,
+      style: {
+        marginLeft: 10
+      }
+    }, this.t(".save_search", {
+      defaultValue: "Save search"
+    })), /*#__PURE__*/React.createElement("button", {
+      className: "load-search-button",
+      onClick: this.tt.onLoadSearchClicked,
+      style: {
+        marginLeft: 10
+      }
+    }, this.t(".load_search", {
+      defaultValue: "Load search"
+    })))));
+  }
+  currentFilters = () => {
+    const {
+      querySName
+    } = digs(this.props, "querySName");
+    const currentFilters = this.queryParams[querySName] || [];
+    return currentFilters.map(currentFilter => JSON.parse(currentFilter));
+  };
+  onAddFilterClicked = e => {
+    e.preventDefault();
+    const newFilterIndex = this.currentFilters().length;
+    this.setState({
+      filter: {
+        filterIndex: newFilterIndex
+      }
+    });
+  };
+  onApplyClicked = () => this.setState({
+    filter: undefined
+  });
+  onEditSearchPressed = ({
+    search
+  }) => {
+    this.onRequestCloseLoadSearchModal();
+    this.setState({
+      showSaveSearchModal: search
+    });
+  };
+  onFilterClicked = filter => this.setState({
+    filter
+  });
+  onLoadSearchClicked = e => {
+    e.preventDefault();
+    this.setState({
+      showLoadSearchModal: true
+    });
+  };
+  onRemoveClicked = ({
+    filterIndex
+  }) => {
+    const {
+      querySName
+    } = digs(this.props, "querySName");
+    const searchParams = Params.parse()[querySName] || {};
+    delete searchParams[filterIndex];
+    const newParams = {};
+    newParams[querySName] = searchParams;
+    Params.changeParams(newParams);
+    this.setState({
+      filter: undefined
+    });
+  };
+  onRequestCloseLoadSearchModal = () => this.setState({
+    showLoadSearchModal: false
+  });
+  onRequestCloseSaveSearchModal = () => this.setState({
+    showSaveSearchModal: undefined
+  });
+  onSaveSearchClicked = e => {
+    e.preventDefault();
+    if (this.hasAnyFilters()) {
+      this.setState({
+        showSaveSearchModal: new TableSearch()
+      });
+    } else {
+      FlashMessage.alert(this.t(".no_filters_has_been_set", {
+        defaultValue: "No filters has been set"
+      }));
+    }
+  };
+  hasAnyFilters = () => Object.keys(this.currentFilters()).length > 0;
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","digg","digs","Filter","FilterForm","LoadSearchModal","SaveSearchModal","PropTypes","memo","shapeComponent","models","useI18n","useQueryParams","View","TableSearch","ApiMakerTableFilters","propTypes","currentUser","object","modelClass","func","isRequired","queryName","string","querySName","setup","t","namespace","queryParams","useStates","filter","undefined","showLoadSearchModal","showSaveSearchModal","render","props","state","currentFilters","React","createElement","dataSet","class","style","alignItems","key","filterIndex","onApplyClicked","querySearchName","onEditSearchPressed","onRequestClose","search","map","filterData","_extends","onClick","tt","onFilterClicked","onRemoveClicked","className","flexDirection","marginTop","onAddFilterClicked","defaultValue","Fragment","onSaveSearchClicked","marginLeft","onLoadSearchClicked","currentFilter","JSON","parse","e","preventDefault","newFilterIndex","length","setState","onRequestCloseLoadSearchModal","searchParams","Params","newParams","changeParams","onRequestCloseSaveSearchModal","hasAnyFilters","FlashMessage","alert","Object","keys"],"sources":["../../../src/table/filters/index.jsx"],"sourcesContent":["import BaseComponent from \"../../base-component\"\nimport {digg, digs} from \"diggerize\"\nimport Filter from \"./filter\"\nimport FilterForm from \"./filter-form\"\nimport LoadSearchModal from \"./load-search-modal\"\nimport SaveSearchModal from \"./save-search-modal\"\nimport PropTypes from \"prop-types\"\nimport memo from \"set-state-compare/src/memo\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport models from \"../../models\"\nimport useI18n from \"i18n-on-steroids/src/use-i18n\"\nimport useQueryParams from \"on-location-changed/src/use-query-params\"\nimport {View} from \"react-native\"\n\nconst {TableSearch} = models\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  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters\"})\n\n    this.queryParams = useQueryParams()\n    this.t = t\n    this.useStates({\n      filter: undefined,\n      showLoadSearchModal: undefined,\n      showSaveSearchModal: false\n    })\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={{class: \"api-maker--table--filters\"}} style={{alignItems: \"flex-start\"}}>\n        {filter &&\n          <FilterForm\n            filter={filter}\n            key={`filter-${filter.filterIndex}`}\n            modelClass={modelClass}\n            onApplyClicked={digg(this, \"onApplyClicked\")}\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 className=\"filter-actions\" style={{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\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      FlashMessage.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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,174 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import apiMakerConfig from "@kaspernj/api-maker/build/config";
+import BaseComponent from "../../base-component";
+import classNames from "classnames";
+import { digg } from "diggerize";
+import memo from "set-state-compare/src/memo";
+import { useMemo } from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import models from "../../models";
+import { Pressable, View } from "react-native";
+import Text from "../../utils/text";
+import useI18n from "i18n-on-steroids/src/use-i18n";
+const {
+  TableSearch
+} = models;
+const SearchLink = memo(shapeComponent(class SearchLink extends BaseComponent {
+  render() {
+    const {
+      search
+    } = this.props;
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        class: "search-row",
+        searchId: search.id()
+      },
+      style: {
+        flexDirection: "row",
+        width: "100%"
+      }
+    }, /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "load-search-link"
+      },
+      onPress: this.onSearchClicked,
+      style: {
+        justifyContent: "center"
+      }
+    }, /*#__PURE__*/React.createElement(Text, null, search.name())), /*#__PURE__*/React.createElement(View, {
+      style: {
+        flexDirection: "row",
+        marginLeft: "auto"
+      }
+    }, /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "edit-search-button"
+      },
+      onPress: this.onEditPressed,
+      style: {
+        alignItems: "center",
+        justifyContent: "center",
+        width: 25,
+        height: 25,
+        backgroundColor: "#fff",
+        border: "1px solid #007bff",
+        borderRadius: 5,
+        color: "#007bff"
+      }
+    }, /*#__PURE__*/React.createElement(Text, null, "\u270E")), /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "delete-search-button"
+      },
+      onPress: this.onDeletePressed,
+      style: {
+        alignItems: "center",
+        justifyContent: "center",
+        marginLeft: 5,
+        width: 25,
+        height: 25,
+        backgroundColor: "#fff",
+        border: "1px solid #dc3545",
+        borderRadius: 5,
+        color: "#dc3545"
+      }
+    }, /*#__PURE__*/React.createElement(Text, null, "\u2715"))));
+  }
+  onDeletePressed = async () => {
+    if (!confirm("Are you sure?")) {
+      return;
+    }
+    const {
+      search
+    } = this.props;
+    await search.destroy();
+    this.props.onDeleted({
+      search
+    });
+  };
+  onEditPressed = () => this.props.onEditPressed({
+    search: this.props.search
+  });
+  onSearchClicked = () => this.props.onClick({
+    search: this.props.search
+  });
+}));
+export default memo(shapeComponent(class ApiMakerTableFiltersLoadSearchModal extends BaseComponent {
+  setup() {
+    const {
+      t
+    } = useI18n({
+      namespace: "js.api_maker.table.filters.load_search_modal"
+    });
+    this.useStates({
+      editSearch: undefined,
+      searches: undefined
+    });
+    this.setInstance({
+      t
+    });
+    useMemo(() => {
+      this.loadSearches();
+    }, []);
+  }
+  loadSearches = async () => {
+    const {
+      currentUser
+    } = this.props;
+    const userType = digg(currentUser.modelClassData(), "name");
+    const searches = await TableSearch.ransack({
+      user_id_eq: currentUser.id(),
+      user_type_eq: userType
+    }).toArray();
+    this.setState({
+      searches
+    });
+  };
+  render() {
+    const {
+      t
+    } = this;
+    const {
+      className,
+      currentUser,
+      modelClass,
+      onEditSearchPressed,
+      onRequestClose,
+      querySearchName,
+      ...restProps
+    } = this.props;
+    const Modal = apiMakerConfig.getModal();
+    return /*#__PURE__*/React.createElement(Modal, _extends({
+      className: classNames("api-maker--table--filters--load-search-modal", className),
+      onRequestClose: onRequestClose
+    }, restProps), /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement(Text, null, t(".choose_a_search", {
+      defaultValue: "Choose a search"
+    }))), this.state.searches?.map(search => /*#__PURE__*/React.createElement(SearchLink, {
+      key: search.id(),
+      onClick: this.onSearchClicked,
+      onDeleted: this.onSearchDeleted,
+      onEditPressed: onEditSearchPressed,
+      search: search
+    })));
+  }
+  onSearchClicked = ({
+    search
+  }) => {
+    const {
+      onRequestClose,
+      querySearchName
+    } = this.props;
+    const queryParams = search.queryParams();
+    const newParams = {};
+    newParams[querySearchName] = queryParams.map(queryParam => JSON.stringify(queryParam));
+    Params.changeParams(newParams);
+    onRequestClose();
+  };
+  onSearchDeleted = ({
+    search
+  }) => {
+    this.setState({
+      searches: this.state.searches.filter(existingSearch => existingSearch.id() != search.id())
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["apiMakerConfig","BaseComponent","classNames","digg","memo","useMemo","shapeComponent","models","Pressable","View","Text","useI18n","TableSearch","SearchLink","render","search","props","React","createElement","dataSet","class","searchId","id","style","flexDirection","width","onPress","onSearchClicked","justifyContent","name","marginLeft","onEditPressed","alignItems","height","backgroundColor","border","borderRadius","color","onDeletePressed","confirm","destroy","onDeleted","onClick","ApiMakerTableFiltersLoadSearchModal","setup","t","namespace","useStates","editSearch","undefined","searches","setInstance","loadSearches","currentUser","userType","modelClassData","ransack","user_id_eq","user_type_eq","toArray","setState","className","modelClass","onEditSearchPressed","onRequestClose","querySearchName","restProps","Modal","getModal","_extends","defaultValue","state","map","key","onSearchDeleted","queryParams","newParams","queryParam","JSON","stringify","Params","changeParams","filter","existingSearch"],"sources":["../../../src/table/filters/load-search-modal.jsx"],"sourcesContent":["import apiMakerConfig from \"@kaspernj/api-maker/build/config\"\nimport BaseComponent from \"../../base-component\"\nimport classNames from \"classnames\"\nimport {digg} from \"diggerize\"\nimport memo from \"set-state-compare/src/memo\"\nimport {useMemo} from \"react\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport models from \"../../models\"\nimport {Pressable, View} from \"react-native\"\nimport Text from \"../../utils/text\"\nimport useI18n from \"i18n-on-steroids/src/use-i18n\"\n\nconst {TableSearch} = models\n\nconst SearchLink = memo(shapeComponent(class SearchLink extends BaseComponent {\n  render() {\n    const {search} = this.props\n\n    return (\n      <View dataSet={{class: \"search-row\", searchId: search.id()}} style={{flexDirection: \"row\", width: \"100%\"}}>\n        <Pressable dataSet={{class: \"load-search-link\"}} onPress={this.onSearchClicked} style={{justifyContent: \"center\"}}>\n          <Text>\n            {search.name()}\n          </Text>\n        </Pressable>\n        <View style={{flexDirection: \"row\", marginLeft: \"auto\"}}>\n          <Pressable\n            dataSet={{class: \"edit-search-button\"}}\n            onPress={this.onEditPressed}\n            style={{\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={{class: \"delete-search-button\"}}\n            onPress={this.onDeletePressed}\n            style={{\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  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters.load_search_modal\"})\n\n    this.useStates({\n      editSearch: undefined,\n      searches: undefined\n    })\n    this.setInstance({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\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.state.searches?.map((search) =>\n          <SearchLink key={search.id()} onClick={this.onSearchClicked} onDeleted={this.onSearchDeleted} onEditPressed={onEditSearchPressed} search={search} />\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.state.searches.filter((existingSearch) => existingSearch.id() != search.id())\n    })\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,36 @@
+import BaseComponent from "../../base-component";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import memo from "set-state-compare/src/memo";
+import { Pressable } from "react-native";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import Text from "../../utils/text";
+export default memo(shapeComponent(class ReflectionElement extends BaseComponent {
+  static propTypes = PropTypesExact({
+    modelClassName: PropTypes.string.isRequired,
+    onClick: PropTypes.func.isRequired,
+    reflection: PropTypes.object.isRequired
+  });
+  render() {
+    const {
+      modelClassName,
+      reflection
+    } = this.p;
+    const {
+      humanName,
+      reflectionName
+    } = reflection;
+    return /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "reflection-element",
+        modelClass: modelClassName,
+        reflectionName
+      },
+      onPress: this.tt.onReflectionClicked
+    }, /*#__PURE__*/React.createElement(Text, null, humanName));
+  }
+  onReflectionClicked = () => this.p.onClick({
+    reflection: this.p.reflection
+  });
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,86 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import apiMakerConfig from "@kaspernj/api-maker/build/config";
+import BaseComponent from "../../base-component";
+import Checkbox from "../../bootstrap/checkbox";
+import { digg } from "diggerize";
+import { Form } from "../../form";
+import Input from "../../bootstrap/input";
+import modelClassRequire from "../../model-class-require";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import memo from "set-state-compare/src/memo";
+import useI18n from "i18n-on-steroids/src/use-i18n";
+const TableSearch = modelClassRequire("TableSearch");
+export default memo(shapeComponent(class ApiMakerTableFiltersSaveSearchModal extends BaseComponent {
+  setup() {
+    const {
+      t
+    } = useI18n({
+      namespace: "js.api_maker.table.filters.save_search_modal"
+    });
+    this.t = t;
+    this.useStates({
+      form: null
+    });
+  }
+  render() {
+    const {
+      currentFilters,
+      currentUser,
+      onRequestClose,
+      search,
+      ...restProps
+    } = this.props;
+    const Modal = apiMakerConfig.getModal();
+    return /*#__PURE__*/React.createElement(Modal, _extends({
+      onRequestClose: onRequestClose
+    }, restProps), /*#__PURE__*/React.createElement(Form, {
+      onSubmit: this.tt.onSaveSearchSubmit,
+      setForm: this.setStates.form
+    }, /*#__PURE__*/React.createElement(Input, {
+      defaultValue: search.name(),
+      id: "table_search_name",
+      label: this.t(".search_name", {
+        defaultValue: "Search name"
+      }),
+      name: "table_search[name]"
+    }), /*#__PURE__*/React.createElement(Checkbox, {
+      defaultChecked: search.public(),
+      id: "table_search_public",
+      label: this.t(".public", {
+        defaultValue: "Public"
+      }),
+      name: "table_search[public]"
+    }), /*#__PURE__*/React.createElement("button", {
+      className: "save-search-submit-button"
+    }, this.t(".save_search", {
+      defaultValue: "Save search"
+    }))));
+  }
+  onSaveSearchSubmit = async () => {
+    const formData = this.s.form.asObject();
+    const {
+      currentFilters,
+      currentUser,
+      onRequestClose,
+      search
+    } = this.p;
+    const hasUserTypeColumn = Boolean(TableSearch.attributes().find(attribute => attribute.name() == "user_type"));
+    if (search.isNewRecord()) {
+      formData.table_search.query_params = JSON.stringify(currentFilters());
+    }
+    if (hasUserTypeColumn) {
+      formData.table_search.user_type = digg(currentUser.modelClassData(), "className");
+    }
+    formData.table_search.user_id = currentUser.id();
+    try {
+      await search.saveRaw(formData);
+      FlashMessage.success(this.t(".", {
+        defaultValue: "The search was saved."
+      }));
+      onRequestClose();
+    } catch (error) {
+      FlashMessage.errorResponse(error);
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,41 @@
+import BaseComponent from "../../base-component";
+import PropTypes from "prop-types";
+import memo from "set-state-compare/src/memo";
+import { Pressable } from "react-native";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import Text from "../../utils/text";
+export default memo(shapeComponent(class ScopeElement extends BaseComponent {
+  static defaultProps = {
+    active: false
+  };
+  static propTypes = {
+    active: PropTypes.bool.isRequired,
+    onScopeClicked: PropTypes.func.isRequired,
+    scope: PropTypes.string.isRequired
+  };
+  render() {
+    const {
+      active,
+      scope
+    } = this.p;
+    const style = {};
+    if (active) style.fontWeight = "bold";
+    return /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "scope-element",
+        scopeName: scope
+      },
+      key: scope,
+      onPress: this.tt.onScopeClicked
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: style
+    }, scope));
+  }
+  onScopeClicked = e => {
+    e.preventDefault();
+    this.p.onScopeClicked({
+      scope: this.p.scope
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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