@kaspernj/api-maker 1.0.2011 → 1.0.2012

package/build/table/filters/filter-form.js

@@ -0,0 +1,402 @@
+import { useMemo, useRef } from "react";
+import { ActivityIndicator, View } from "react-native";
+import AttributeElement from "./attribute-element";
+import BaseComponent from "../../base-component";
+import { digg, digs } from "diggerize";
+import * as inflection from "inflection";
+import { Form } from "../../form";
+import Input from "../../inputs/input";
+import memo from "set-state-compare/src/memo";
+import Params from "../../params";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import React from "react";
+import ReflectionElement from "./reflection-element";
+import ScopeElement from "./scope-element";
+import Select from "../../inputs/select";
+import Services from "../../services";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import Text from "../../utils/text";
+import useI18n from "i18n-on-steroids/src/use-i18n";
+export default memo(shapeComponent(class ApiMakerTableFiltersFilterForm extends BaseComponent {
+  static propTypes = PropTypesExact({
+    filter: PropTypes.object,
+    modelClass: PropTypes.func.isRequired,
+    onApplyClicked: PropTypes.func.isRequired,
+    querySearchName: PropTypes.string.isRequired
+  });
+  setup() {
+    const {
+      t
+    } = useI18n({
+      namespace: "js.api_maker.table.filters.filter_form"
+    });
+    this.useStates({
+      associations: null,
+      attribute: undefined,
+      actualCurrentModelClass: () => ({
+        modelClass: this.p.modelClass
+      }),
+      loading: 0,
+      modelClassName: digg(this.p.modelClass.modelClassData(), "className"),
+      path: [],
+      predicate: undefined,
+      predicates: undefined,
+      ransackableAttributes: undefined,
+      ransackableScopes: undefined,
+      scope: this.props.filter.sc,
+      value: this.props.filter.v
+    });
+    this.setInstance({
+      t,
+      valueInputRef: useRef()
+    });
+    useMemo(() => {
+      this.loadRansackPredicates();
+      if (this.props.filter.v) {
+        this.loadInitialValuesWithLoadingIndicator();
+      }
+    }, []);
+    useMemo(() => {
+      this.loadAssociations();
+    }, [this.s.modelClassName]);
+  }
+  currentModelClass = () => digg(this.s.actualCurrentModelClass, "modelClass");
+  parseAssociationData(result) {
+    const associations = result.associations.map(({
+      human_name,
+      model_class_name,
+      reflection_name,
+      resource
+    }) => ({
+      humanName: human_name,
+      modelClassName: model_class_name,
+      reflectionName: inflection.camelize(reflection_name, true),
+      resource
+    }));
+    const ransackableAttributes = digg(result, "ransackable_attributes").map(({
+      attribute_name: attributeName,
+      human_name: humanName
+    }) => ({
+      attributeName,
+      humanName
+    }));
+    const ransackableScopes = digg(result, "ransackable_scopes");
+    return {
+      associations,
+      ransackableAttributes,
+      ransackableScopes
+    };
+  }
+  async loadAssociations() {
+    this.increaseLoading();
+    try {
+      if (!this.s.modelClassName) throw new Error("'modelClassName' not set in state");
+      const result = await Services.current().sendRequest("Models::Associations", {
+        model_class_name: this.s.modelClassName
+      });
+      const {
+        associations,
+        ransackableAttributes,
+        ransackableScopes
+      } = this.parseAssociationData(result);
+      this.setState({
+        associations,
+        ransackableAttributes,
+        ransackableScopes
+      });
+    } finally {
+      this.decreaseLoading();
+    }
+  }
+  decreaseLoading = () => this.setState(prevState => ({
+    loading: prevState.loading - 1
+  }));
+  increaseLoading = () => this.setState(prevState => ({
+    loading: prevState.loading + 1
+  }));
+  async loadInitialValuesWithLoadingIndicator() {
+    try {
+      this.increaseLoading();
+      await this.loadInitialValues();
+    } finally {
+      this.decreaseLoading();
+    }
+  }
+  async loadInitialValues() {
+    if (!this.s.modelClassName) throw new Error("'modelClassName' not set in state");
+    let result = await Services.current().sendRequest("Models::Associations", {
+      model_class_name: this.s.modelClassName
+    });
+    let data = this.parseAssociationData(result);
+    let modelClassName = this.s.modelClassName;
+    const path = [];
+    for (const pathPart of this.props.filter.p) {
+      const reflection = data.associations.find(association => digg(association, "reflectionName") == inflection.camelize(pathPart, true));
+      if (!reflection) throw new Error(`Couldn't find association by that name ${this.s.modelClassName}#${pathPart}`);
+      modelClassName = digg(reflection, "modelClassName");
+      if (!modelClassName) {
+        const pathNames = path.map(pathPart => pathPart.name()).join(".");
+        throw new Error(`No model class name from ${pathNames}.${reflection.name()}`);
+      }
+      result = await Services.current().sendRequest("Models::Associations", {
+        model_class_name: modelClassName
+      });
+      data = this.parseAssociationData(result);
+      path.push(reflection);
+    }
+    const {
+      ransackableAttributes
+    } = data;
+    const attribute = this.p.filter.a;
+    const ransackableAttribute = ransackableAttributes.find(ransackableAttribute => digg(ransackableAttribute, "attributeName") == attribute);
+    this.setState({
+      attribute: ransackableAttribute,
+      modelClassName,
+      path
+    });
+  }
+  async loadRansackPredicates() {
+    this.increaseLoading();
+    try {
+      const response = await Services.current().sendRequest("Ransack::Predicates");
+      const predicates = digg(response, "predicates");
+      let currentPredicate;
+      if (this.props.filter.pre) {
+        currentPredicate = predicates.find(predicate => predicate.name == this.props.filter.pre);
+      }
+      this.setState({
+        predicate: currentPredicate,
+        predicates
+      });
+    } finally {
+      this.decreaseLoading();
+    }
+  }
+  render() {
+    const {
+      t,
+      valueInputRef
+    } = this.tt;
+    const {
+      attribute,
+      path,
+      predicate,
+      predicates,
+      scope,
+      value
+    } = this.s;
+    let submitEnabled = false;
+    if (attribute && predicate) {
+      submitEnabled = true;
+    } else if (scope) {
+      submitEnabled = true;
+    }
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        class: "api-maker--table--filters--filter-form"
+      },
+      style: {
+        minWidth: 50,
+        minHeight: 50
+      }
+    }, /*#__PURE__*/React.createElement(Form, {
+      onSubmit: this.tt.onSubmit
+    }, /*#__PURE__*/React.createElement(View, {
+      style: {
+        flexDirection: "row"
+      }
+    }, path.map(({
+      humanName,
+      reflectionName
+    }, pathPartIndex) => /*#__PURE__*/React.createElement(View, {
+      key: `${pathPartIndex}-${reflectionName}`,
+      style: {
+        flexDirection: "row"
+      }
+    }, pathPartIndex > 0 && /*#__PURE__*/React.createElement(Text, {
+      style: {
+        marginRight: 5,
+        marginLeft: 5
+      }
+    }, "-"), /*#__PURE__*/React.createElement(Text, null, humanName)))), /*#__PURE__*/React.createElement(View, {
+      style: {
+        flexDirection: "row"
+      }
+    }, /*#__PURE__*/React.createElement(View, null, this.s.associations && this.sortedReflectionsByName(this.s.associations).map(reflection => /*#__PURE__*/React.createElement(ReflectionElement, {
+      key: reflection.reflectionName,
+      modelClassName: this.s.modelClassName,
+      onClick: this.tt.onReflectionClicked,
+      reflection: reflection
+    }))), /*#__PURE__*/React.createElement(View, null, this.s.ransackableAttributes && this.sortedAttributesByName(this.s.ransackableAttributes)?.map(attribute => /*#__PURE__*/React.createElement(AttributeElement, {
+      active: attribute.attributeName == this.s.attribute?.attributeName,
+      attribute: attribute,
+      key: attribute.attributeName,
+      modelClassName: this.s.modelClassName,
+      onClick: this.tt.onAttributeClicked
+    })), this.s.ransackableScopes?.map(scope => /*#__PURE__*/React.createElement(ScopeElement, {
+      active: scope == this.s.scope,
+      key: scope,
+      scope: scope,
+      onScopeClicked: this.tt.onScopeClicked
+    }))), /*#__PURE__*/React.createElement(View, null, predicates && !this.s.scope && /*#__PURE__*/React.createElement(Select, {
+      className: "predicate-select",
+      defaultValue: predicate?.name,
+      includeBlank: true,
+      onChange: this.tt.onPredicateChanged,
+      options: predicates.map(predicate => digg(predicate, "name"))
+    })), /*#__PURE__*/React.createElement(View, null, (attribute && predicate || scope) && /*#__PURE__*/React.createElement(Input, {
+      className: "value-input",
+      defaultValue: value,
+      inputRef: valueInputRef
+    }))), /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement("button", {
+      className: "apply-filter-button",
+      disabled: !submitEnabled
+    }, t(".apply", {
+      defaultValue: "Apply"
+    })))), this.s.loading > 0 && /*#__PURE__*/React.createElement(View, {
+      style: {
+        alignItems: "center",
+        justifyContent: "center",
+        position: "absolute",
+        width: "100%",
+        height: "100%"
+      }
+    }, /*#__PURE__*/React.createElement(ActivityIndicator, {
+      size: "large"
+    })));
+  }
+  currentModelClassFromPath(path) {
+    const {
+      modelClass
+    } = this.p;
+    let currentModelClass = modelClass;
+    for (const pathPart of path) {
+      const camelizedPathPart = inflection.camelize(pathPart, true);
+      const association = currentModelClass.ransackableAssociations().find(reflection => reflection.name() == camelizedPathPart);
+      if (!association) {
+        const ransackableAssociationNames = currentModelClass.ransackableAssociations().map(reflection => reflection.name()).join(", ");
+        throw new Error(`Could not find a Ransackable association by that name: ${camelizedPathPart} in ${ransackableAssociationNames}`);
+      }
+      currentModelClass = association.modelClass();
+    }
+    return currentModelClass;
+  }
+  currentPathParts() {
+    const {
+      modelClass
+    } = this.p;
+    const {
+      path
+    } = this.s;
+    const result = [];
+    let currentModelClass = modelClass;
+    result.push({
+      modelClass,
+      translation: modelClass.modelName().human({
+        count: 2
+      })
+    });
+    for (const pathPart of path) {
+      const camelizedPathPart = inflection.camelize(pathPart, true);
+      const pathPartTranslation = currentModelClass.humanAttributeName(camelizedPathPart);
+      currentModelClass = currentModelClass.ransackableAssociations().find(reflection => reflection.name() == camelizedPathPart).modelClass();
+      result.push({
+        modelClass: currentModelClass,
+        translation: pathPartTranslation
+      });
+    }
+    return result;
+  }
+  onAttributeClicked = ({
+    attribute
+  }) => {
+    this.setState({
+      attribute,
+      scope: undefined
+    });
+  };
+  onPredicateChanged = e => {
+    const chosenPredicateName = digg(e, "target", "value");
+    const predicate = this.s.predicates.find(predicate => predicate.name == chosenPredicateName);
+    this.setState({
+      predicate
+    });
+  };
+  onReflectionClicked = ({
+    reflection
+  }) => {
+    const newPath = this.s.path.concat([reflection]);
+    this.setState({
+      associations: null,
+      attribute: undefined,
+      actualCurrentModelClass: {
+        modelClass: digg(reflection, "resource")
+      },
+      modelClassName: digg(reflection, "modelClassName"),
+      path: newPath,
+      predicate: undefined
+    });
+  };
+  onScopeClicked = ({
+    scope
+  }) => {
+    this.setState({
+      attribute: undefined,
+      predicate: undefined,
+      scope
+    });
+  };
+  onSubmit = () => {
+    const {
+      filter,
+      querySearchName
+    } = this.p;
+    const {
+      attribute,
+      path,
+      predicate,
+      scope
+    } = this.s;
+    const {
+      filterIndex
+    } = digs(filter, "filterIndex");
+    const searchParams = Params.parse()[querySearchName] || {};
+    const value = digg(this.tt.valueInputRef, "current", "value");
+    const p = path.map(reflection => inflection.underscore(reflection.reflectionName));
+    const newSearchParams = {
+      p,
+      v: value
+    };
+    if (attribute) {
+      newSearchParams.a = digg(attribute, "attributeName");
+      newSearchParams.pre = digg(predicate, "name");
+    } else if (scope) {
+      newSearchParams.sc = scope;
+    } else {
+      throw new Error("Dont know if should search for attribute or scope?");
+    }
+    searchParams[filterIndex] = JSON.stringify(newSearchParams);
+    const newParams = {};
+    newParams[querySearchName] = searchParams;
+    Params.changeParams(newParams);
+    this.props.onApplyClicked();
+  };
+  reflectionsWithModelClass(reflections) {
+    return reflections.filter(reflection => {
+      try {
+        reflection.modelClass();
+        return true;
+      } catch (error) {
+        return false;
+      }
+    });
+  }
+  sortedAttributesByName(attributes) {
+    return attributes.sort((a, b) => digg(a, "humanName").toLowerCase().localeCompare(digg(b, "humanName").toLowerCase()));
+  }
+  sortedReflectionsByName(reflections) {
+    return reflections.sort((a, b) => digg(a, "humanName").toLowerCase().localeCompare(digg(b, "humanName").toLowerCase()));
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useMemo","useRef","ActivityIndicator","View","AttributeElement","BaseComponent","digg","digs","inflection","Form","Input","memo","Params","PropTypes","PropTypesExact","React","ReflectionElement","ScopeElement","Select","Services","shapeComponent","Text","useI18n","ApiMakerTableFiltersFilterForm","propTypes","filter","object","modelClass","func","isRequired","onApplyClicked","querySearchName","string","setup","t","namespace","useStates","associations","attribute","undefined","actualCurrentModelClass","p","loading","modelClassName","modelClassData","path","predicate","predicates","ransackableAttributes","ransackableScopes","scope","props","sc","value","v","setInstance","valueInputRef","loadRansackPredicates","loadInitialValuesWithLoadingIndicator","loadAssociations","s","currentModelClass","parseAssociationData","result","map","human_name","model_class_name","reflection_name","resource","humanName","reflectionName","camelize","attribute_name","attributeName","increaseLoading","Error","current","sendRequest","setState","decreaseLoading","prevState","loadInitialValues","data","pathPart","reflection","find","association","pathNames","name","join","push","a","ransackableAttribute","response","currentPredicate","pre","render","tt","submitEnabled","createElement","dataSet","class","style","minWidth","minHeight","onSubmit","flexDirection","pathPartIndex","key","marginRight","marginLeft","sortedReflectionsByName","onClick","onReflectionClicked","sortedAttributesByName","active","onAttributeClicked","onScopeClicked","className","defaultValue","includeBlank","onChange","onPredicateChanged","options","inputRef","disabled","alignItems","justifyContent","position","width","height","size","currentModelClassFromPath","camelizedPathPart","ransackableAssociations","ransackableAssociationNames","currentPathParts","translation","modelName","human","count","pathPartTranslation","humanAttributeName","e","chosenPredicateName","newPath","concat","filterIndex","searchParams","parse","underscore","newSearchParams","JSON","stringify","newParams","changeParams","reflectionsWithModelClass","reflections","error","attributes","sort","b","toLowerCase","localeCompare"],"sources":["../../../src/table/filters/filter-form.jsx"],"sourcesContent":["import {useMemo, useRef} from \"react\"\nimport {ActivityIndicator, View} from \"react-native\"\nimport AttributeElement from \"./attribute-element\"\nimport BaseComponent from \"../../base-component\"\nimport {digg, digs} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport {Form} from \"../../form\"\nimport Input from \"../../inputs/input\"\nimport memo from \"set-state-compare/src/memo\"\nimport Params from \"../../params\"\nimport PropTypes from \"prop-types\"\nimport PropTypesExact from \"prop-types-exact\"\nimport React from \"react\"\nimport ReflectionElement from \"./reflection-element\"\nimport ScopeElement from \"./scope-element\"\nimport Select from \"../../inputs/select\"\nimport Services from \"../../services\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport Text from \"../../utils/text\"\nimport useI18n from \"i18n-on-steroids/src/use-i18n\"\n\nexport default memo(shapeComponent(class ApiMakerTableFiltersFilterForm extends BaseComponent {\n  static propTypes = PropTypesExact({\n    filter: PropTypes.object,\n    modelClass: PropTypes.func.isRequired,\n    onApplyClicked: PropTypes.func.isRequired,\n    querySearchName: PropTypes.string.isRequired\n  })\n\n  setup() {\n    const {t} = useI18n({namespace: \"js.api_maker.table.filters.filter_form\"})\n\n    this.useStates({\n      associations: null,\n      attribute: undefined,\n      actualCurrentModelClass: () => ({modelClass: this.p.modelClass}),\n      loading: 0,\n      modelClassName: digg(this.p.modelClass.modelClassData(), \"className\"),\n      path: [],\n      predicate: undefined,\n      predicates: undefined,\n      ransackableAttributes: undefined,\n      ransackableScopes: undefined,\n      scope: this.props.filter.sc,\n      value: this.props.filter.v\n    })\n\n    this.setInstance({\n      t,\n      valueInputRef: useRef(),\n    })\n\n    useMemo(() => {\n      this.loadRansackPredicates()\n\n      if (this.props.filter.v) {\n        this.loadInitialValuesWithLoadingIndicator()\n      }\n    }, [])\n\n    useMemo(() => {\n      this.loadAssociations()\n    }, [this.s.modelClassName])\n  }\n\n  currentModelClass = () => digg(this.s.actualCurrentModelClass, \"modelClass\")\n\n  parseAssociationData(result) {\n    const associations = result.associations.map(({human_name, model_class_name, reflection_name, resource}) => ({\n      humanName: human_name,\n      modelClassName: model_class_name,\n      reflectionName: inflection.camelize(reflection_name, true),\n      resource\n    }))\n    const ransackableAttributes = digg(result, \"ransackable_attributes\").map(({attribute_name: attributeName, human_name: humanName}) => ({\n      attributeName, humanName\n    }))\n    const ransackableScopes = digg(result, \"ransackable_scopes\")\n\n    return {associations, ransackableAttributes, ransackableScopes}\n  }\n\n  async loadAssociations() {\n    this.increaseLoading()\n\n    try {\n      if (!this.s.modelClassName) throw new Error(\"'modelClassName' not set in state\")\n\n      const result = await Services.current().sendRequest(\"Models::Associations\", {model_class_name: this.s.modelClassName})\n      const {associations, ransackableAttributes, ransackableScopes} = this.parseAssociationData(result)\n\n      this.setState({associations, ransackableAttributes, ransackableScopes})\n    } finally {\n      this.decreaseLoading()\n    }\n  }\n\n  decreaseLoading = () => this.setState((prevState) => ({loading: prevState.loading - 1}))\n  increaseLoading = () => this.setState((prevState) => ({loading: prevState.loading + 1}))\n\n  async loadInitialValuesWithLoadingIndicator() {\n    try {\n      this.increaseLoading()\n      await this.loadInitialValues()\n    } finally {\n      this.decreaseLoading()\n    }\n  }\n\n  async loadInitialValues() {\n    if (!this.s.modelClassName) throw new Error(\"'modelClassName' not set in state\")\n\n    let result = await Services.current().sendRequest(\"Models::Associations\", {model_class_name: this.s.modelClassName})\n    let data = this.parseAssociationData(result)\n    let modelClassName = this.s.modelClassName\n    const path = []\n\n    for (const pathPart of this.props.filter.p) {\n      const reflection = data.associations.find((association) => digg(association, \"reflectionName\") == inflection.camelize(pathPart, true))\n\n      if (!reflection) throw new Error(`Couldn't find association by that name ${this.s.modelClassName}#${pathPart}`)\n\n      modelClassName = digg(reflection, \"modelClassName\")\n\n      if (!modelClassName) {\n        const pathNames = path.map((pathPart) => pathPart.name()).join(\".\")\n\n        throw new Error(`No model class name from ${pathNames}.${reflection.name()}`)\n      }\n\n      result = await Services.current().sendRequest(\"Models::Associations\", {model_class_name: modelClassName})\n      data = this.parseAssociationData(result)\n\n      path.push(reflection)\n    }\n\n    const {ransackableAttributes} = data\n    const attribute = this.p.filter.a\n    const ransackableAttribute = ransackableAttributes.find((ransackableAttribute) => digg(ransackableAttribute, \"attributeName\") == attribute)\n\n    this.setState({attribute: ransackableAttribute, modelClassName, path})\n  }\n\n  async loadRansackPredicates() {\n    this.increaseLoading()\n\n    try {\n      const response = await Services.current().sendRequest(\"Ransack::Predicates\")\n      const predicates = digg(response, \"predicates\")\n      let currentPredicate\n\n      if (this.props.filter.pre) {\n        currentPredicate = predicates.find((predicate) => predicate.name == this.props.filter.pre)\n      }\n\n      this.setState({\n        predicate: currentPredicate,\n        predicates\n      })\n    } finally {\n      this.decreaseLoading()\n    }\n  }\n\n  render() {\n    const {t, valueInputRef} = this.tt\n    const {attribute, path, predicate, predicates, scope, value} = this.s\n    let submitEnabled = false\n\n    if (attribute && predicate) {\n      submitEnabled = true\n    } else if (scope) {\n      submitEnabled = true\n    }\n\n    return (\n      <View dataSet={{class: \"api-maker--table--filters--filter-form\"}} style={{minWidth: 50, minHeight: 50}}>\n        <Form onSubmit={this.tt.onSubmit}>\n          <View style={{flexDirection: \"row\"}}>\n            {path.map(({humanName, reflectionName}, pathPartIndex) =>\n              <View key={`${pathPartIndex}-${reflectionName}`} style={{flexDirection: \"row\"}}>\n                {pathPartIndex > 0 &&\n                  <Text style={{marginRight: 5, marginLeft: 5}}>\n                    -\n                  </Text>\n                }\n                <Text>\n                  {humanName}\n                </Text>\n              </View>\n            )}\n          </View>\n          <View style={{flexDirection: \"row\"}}>\n            <View>\n              {this.s.associations && this.sortedReflectionsByName(this.s.associations).map((reflection) =>\n                <ReflectionElement\n                  key={reflection.reflectionName}\n                  modelClassName={this.s.modelClassName}\n                  onClick={this.tt.onReflectionClicked}\n                  reflection={reflection}\n                />\n              )}\n            </View>\n            <View>\n              {this.s.ransackableAttributes && this.sortedAttributesByName(this.s.ransackableAttributes)?.map((attribute) =>\n                <AttributeElement\n                  active={attribute.attributeName == this.s.attribute?.attributeName}\n                  attribute={attribute}\n                  key={attribute.attributeName}\n                  modelClassName={this.s.modelClassName}\n                  onClick={this.tt.onAttributeClicked}\n                />\n              )}\n              {this.s.ransackableScopes?.map((scope) =>\n                <ScopeElement\n                  active={scope == this.s.scope}\n                  key={scope}\n                  scope={scope}\n                  onScopeClicked={this.tt.onScopeClicked}\n                />\n              )}\n            </View>\n            <View>\n              {predicates && !this.s.scope &&\n                <Select\n                  className=\"predicate-select\"\n                  defaultValue={predicate?.name}\n                  includeBlank\n                  onChange={this.tt.onPredicateChanged}\n                  options={predicates.map((predicate) => digg(predicate, \"name\"))}\n                />\n              }\n            </View>\n            <View>\n              {((attribute && predicate) || scope) &&\n                <Input className=\"value-input\" defaultValue={value} inputRef={valueInputRef} />\n              }\n            </View>\n          </View>\n          <View>\n            <button className=\"apply-filter-button\" disabled={!submitEnabled}>\n              {t(\".apply\", {defaultValue: \"Apply\"})}\n            </button>\n          </View>\n        </Form>\n        {this.s.loading > 0 &&\n          <View\n            style={{\n              alignItems: \"center\",\n              justifyContent: \"center\",\n              position: \"absolute\",\n              width: \"100%\",\n              height: \"100%\"\n            }}\n          >\n            <ActivityIndicator size=\"large\" />\n          </View>\n        }\n      </View>\n    )\n  }\n\n  currentModelClassFromPath(path) {\n    const {modelClass} = this.p\n    let currentModelClass = modelClass\n\n    for (const pathPart of path) {\n      const camelizedPathPart = inflection.camelize(pathPart, true)\n      const association = currentModelClass.ransackableAssociations().find((reflection) => reflection.name() == camelizedPathPart)\n\n      if (!association) {\n        const ransackableAssociationNames = currentModelClass.ransackableAssociations().map((reflection) => reflection.name()).join(\", \")\n\n        throw new Error(`Could not find a Ransackable association by that name: ${camelizedPathPart} in ${ransackableAssociationNames}`)\n      }\n\n      currentModelClass = association.modelClass()\n    }\n\n    return currentModelClass\n  }\n\n  currentPathParts() {\n    const {modelClass} = this.p\n    const {path} = this.s\n    const result = []\n    let currentModelClass = modelClass\n\n    result.push({\n      modelClass,\n      translation: modelClass.modelName().human({count: 2})\n    })\n\n    for (const pathPart of path) {\n      const camelizedPathPart = inflection.camelize(pathPart, true)\n      const pathPartTranslation = currentModelClass.humanAttributeName(camelizedPathPart)\n\n      currentModelClass = currentModelClass.ransackableAssociations().find((reflection) => reflection.name() == camelizedPathPart).modelClass()\n\n      result.push({\n        modelClass: currentModelClass,\n        translation: pathPartTranslation\n      })\n    }\n\n    return result\n  }\n\n  onAttributeClicked = ({attribute}) => {\n    this.setState({\n      attribute,\n      scope: undefined\n    })\n  }\n\n  onPredicateChanged = (e) => {\n    const chosenPredicateName = digg(e, \"target\", \"value\")\n    const predicate = this.s.predicates.find((predicate) => predicate.name == chosenPredicateName)\n\n    this.setState({predicate})\n  }\n\n  onReflectionClicked = ({reflection}) => {\n    const newPath = this.s.path.concat([reflection])\n\n    this.setState({\n      associations: null,\n      attribute: undefined,\n      actualCurrentModelClass: {modelClass: digg(reflection, \"resource\")},\n      modelClassName: digg(reflection, \"modelClassName\"),\n      path: newPath,\n      predicate: undefined\n    })\n  }\n\n  onScopeClicked = ({scope}) => {\n    this.setState({\n      attribute: undefined,\n      predicate: undefined,\n      scope\n    })\n  }\n\n  onSubmit = () => {\n    const {filter, querySearchName} = this.p\n    const {attribute, path, predicate, scope} = this.s\n    const {filterIndex} = digs(filter, \"filterIndex\")\n    const searchParams = Params.parse()[querySearchName] || {}\n    const value = digg(this.tt.valueInputRef, \"current\", \"value\")\n    const p = path.map((reflection) => inflection.underscore(reflection.reflectionName))\n    const newSearchParams = {\n      p,\n      v: value\n    }\n\n    if (attribute) {\n      newSearchParams.a = digg(attribute, \"attributeName\")\n      newSearchParams.pre = digg(predicate, \"name\")\n    } else if (scope) {\n      newSearchParams.sc = scope\n    } else {\n      throw new Error(\"Dont know if should search for attribute or scope?\")\n    }\n\n    searchParams[filterIndex] = JSON.stringify(newSearchParams)\n\n    const newParams = {}\n\n    newParams[querySearchName] = searchParams\n\n    Params.changeParams(newParams)\n\n    this.props.onApplyClicked()\n  }\n\n  reflectionsWithModelClass(reflections) {\n    return reflections.filter((reflection) => {\n      try {\n        reflection.modelClass()\n\n        return true\n      } catch (error) {\n        return false\n      }\n    })\n  }\n\n  sortedAttributesByName(attributes) {\n    return attributes.sort((a, b) =>\n      digg(a, \"humanName\")\n        .toLowerCase()\n        .localeCompare(\n          digg(b, \"humanName\").toLowerCase()\n        )\n    )\n  }\n\n  sortedReflectionsByName(reflections) {\n    return reflections.sort((a, b) =>\n      digg(a, \"humanName\")\n        .toLowerCase()\n        .localeCompare(\n          digg(b, \"humanName\").toLowerCase()\n        )\n    )\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/table/filters/filter.js

@@ -0,0 +1,90 @@
+import { Pressable, View } from "react-native";
+import BaseComponent from "../../base-component";
+import Icon from "../../utils/icon";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import memo from "set-state-compare/src/memo";
+import React from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import Text from "../../utils/text";
+export default memo(shapeComponent(class ApiMakerTableFilter extends BaseComponent {
+  static defaultProps = {
+    a: null,
+    pre: null
+  };
+  static propTypes = PropTypesExact({
+    a: PropTypes.string,
+    filterIndex: PropTypes.number.isRequired,
+    onClick: PropTypes.func.isRequired,
+    onRemoveClicked: PropTypes.func.isRequired,
+    p: PropTypes.array.isRequired,
+    pre: PropTypes.string,
+    sc: PropTypes.string,
+    v: PropTypes.string.isRequired
+  });
+  render() {
+    const {
+      p,
+      v
+    } = this.p;
+    const {
+      a,
+      pre,
+      sc
+    } = this.props;
+    return /*#__PURE__*/React.createElement(View, {
+      style: {
+        alignItems: "center",
+        flexDirection: "row",
+        backgroundColor: "grey",
+        paddingVertical: 10,
+        paddingHorizontal: 6
+      }
+    }, /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        attribute: a,
+        class: "filter-label",
+        scope: sc
+      },
+      onPress: this.tt.onFilterPressed
+    }, /*#__PURE__*/React.createElement(Text, null, p.length > 0 && `${p.join(".")}.`, a, " ", sc, " ", pre, " ", v)), /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "remove-filter-button"
+      },
+      onPress: this.tt.onRemoveFilterPressed,
+      style: {
+        marginLeft: 6
+      }
+    }, /*#__PURE__*/React.createElement(Icon, {
+      name: "remove"
+    })));
+  }
+  onFilterPressed = e => {
+    e.preventDefault();
+    const {
+      a,
+      filterIndex,
+      p,
+      pre,
+      v
+    } = this.p;
+    const {
+      sc
+    } = this.props;
+    this.props.onClick({
+      a,
+      filterIndex,
+      p,
+      pre,
+      sc,
+      v
+    });
+  };
+  onRemoveFilterPressed = e => {
+    e.preventDefault();
+    this.props.onRemoveClicked({
+      filterIndex: this.p.filterIndex
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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