@kaspernj/api-maker 1.0.445 → 1.0.447

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

@@ -0,0 +1,43 @@
+import BaseComponent from "../../base-component";
+import { digg } from "diggerize";
+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 AttributeElement extends BaseComponent {
+  static propTypes = PropTypesExact({
+    active: PropTypes.bool.isRequired,
+    attribute: PropTypes.object.isRequired,
+    modelClassName: PropTypes.string.isRequired,
+    fikter: PropTypes.object,
+    onClick: PropTypes.func.isRequired
+  });
+  render() {
+    const {
+      active,
+      attribute,
+      modelClassName
+    } = this.p;
+    const style = {};
+    if (active) style.fontWeight = "bold";
+    return /*#__PURE__*/React.createElement(Pressable, {
+      dataSet: {
+        class: "attribute-element",
+        attributeName: digg(attribute, "attributeName"),
+        modelClass: modelClassName
+      },
+      onPress: this.tt.onAttributeClicked
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: style
+    }, digg(attribute, "humanName")));
+  }
+  onAttributeClicked = e => {
+    e.preventDefault();
+    this.p.onClick({
+      attribute: this.p.attribute
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,392 @@
+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 PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import { useMemo, useRef } from "react";
+import { ActivityIndicator, View } from "react-native";
+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";
+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() {
+    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({
+      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 {
+      valueInputRef
+    } = digs(this, "valueInputRef");
+    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
+    }, I18n.t("js.api_maker.table.filters.relationship_select.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":["AttributeElement","BaseComponent","digg","digs","inflection","Form","Input","memo","PropTypes","PropTypesExact","useMemo","useRef","ActivityIndicator","View","ReflectionElement","ScopeElement","Select","Services","shapeComponent","Text","ApiMakerTableFiltersFilterForm","propTypes","filter","object","modelClass","func","isRequired","onApplyClicked","querySearchName","string","setup","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","submitEnabled","React","createElement","dataSet","class","style","minWidth","minHeight","onSubmit","tt","flexDirection","pathPartIndex","key","marginRight","marginLeft","sortedReflectionsByName","onClick","onReflectionClicked","sortedAttributesByName","active","onAttributeClicked","onScopeClicked","className","defaultValue","includeBlank","onChange","onPredicateChanged","options","inputRef","disabled","I18n","t","alignItems","justifyContent","position","width","height","size","currentModelClassFromPath","camelizedPathPart","ransackableAssociations","ransackableAssociationNames","currentPathParts","translation","modelName","human","count","pathPartTranslation","humanAttributeName","e","chosenPredicateName","newPath","concat","filterIndex","searchParams","Params","parse","underscore","newSearchParams","JSON","stringify","newParams","changeParams","reflectionsWithModelClass","reflections","error","attributes","sort","b","toLowerCase","localeCompare"],"sources":["../../../src/table/filters/filter-form.jsx"],"sourcesContent":["import 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 PropTypes from \"prop-types\"\nimport PropTypesExact from \"prop-types-exact\"\nimport {useMemo, useRef} from \"react\"\nimport {ActivityIndicator, View} from \"react-native\"\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\"\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    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({valueInputRef: useRef()})\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 {valueInputRef} = digs(this, \"valueInputRef\")\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              {I18n.t(\"js.api_maker.table.filters.relationship_select.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,89 @@
+import { Pressable, View } from "react-native";
+import BaseComponent from "../../base-component";
+import FontAwesomeIcon from "react-native-vector-icons/FontAwesome";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import memo from "set-state-compare/src/memo";
+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(FontAwesomeIcon, {
+      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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