@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/bootstrap/checkboxes.js

@@ -0,0 +1,183 @@
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import React, { useMemo } from "react";
+import { digs } from "diggerize";
+import { useForm } from "../form";
+import * as inflection from "inflection";
+import InvalidFeedback from "./invalid-feedback";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import useInput from "../use-input";
+const OptionElement = memo(shapeComponent(class OptionElement extends ShapeComponent {
+  render() {
+    const {
+      generatedId,
+      inputCheckboxClassName,
+      isDefaultSelected,
+      inputName,
+      option,
+      optionIndex,
+      options,
+      wrapperOpts
+    } = this.p;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    const id = `${generatedId}-${optionIndex}`;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "checkboxes-option",
+      key: `option-${option[1]}`
+    }, /*#__PURE__*/React.createElement("input", {
+      className: inputCheckboxClassName,
+      "data-option-value": option[1],
+      defaultChecked: isDefaultSelected,
+      id: id,
+      name: inputName,
+      onChange: this.tt.onChange,
+      type: "checkbox",
+      value: option[1]
+    }), /*#__PURE__*/React.createElement("label", {
+      className: "ml-1",
+      htmlFor: id
+    }, option[0]), optionIndex + 1 == options.length && errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    }));
+  }
+  onChange = (event, ...restProps) => {
+    this.p.onOptionChecked({
+      event,
+      option: this.p.option
+    });
+    if (this.props.onChange) this.props.onChange(event, ...restProps);
+  };
+}));
+export default memo(shapeComponent(class ApiMakerBootstrapCheckboxes extends ShapeComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.string,
+    defaultValue: PropTypes.array,
+    label: PropTypes.string,
+    labelClassName: PropTypes.string,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    onChange: PropTypes.func,
+    options: PropTypes.array.isRequired
+  });
+  setup() {
+    const {
+      inputProps,
+      wrapperOpts
+    } = useInput({
+      props: this.props
+    });
+    this.generatedId = useMemo(() => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15), []);
+    this.setInstance({
+      form: useForm(),
+      inputProps,
+      wrapperOpts
+    });
+    this.useStates({
+      checkedOptions: () => {
+        if (Array.isArray(this.props.defaultValue)) return this.props.defaultValue;
+        if (this.props.defaultValue) return [this.props.defaultValue];
+        return [];
+      }
+    });
+    useMemo(() => {
+      if (this.form && inputProps.name) {
+        this.form.setValue(inputProps.name, this.s.checkedOptions);
+      }
+    }, []);
+  }
+  render() {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "component-bootstrap-checkboxes form-group"
+    }, /*#__PURE__*/React.createElement("label", {
+      className: this.labelClassName()
+    }, this.tt.wrapperOpts.label), /*#__PURE__*/React.createElement("input", {
+      name: this.inputName(),
+      ref: this.tt.inputProps.ref,
+      type: "hidden",
+      value: ""
+    }), this.props.options.map((option, index) => /*#__PURE__*/React.createElement(OptionElement, {
+      inputCheckboxClassName: this.tt.inputCheckboxClassName(),
+      inputName: this.inputName(),
+      isDefaultSelected: this.isDefaultSelected(option[1]),
+      generatedId: this.tt.generatedId,
+      key: option[1],
+      onChange: this.props.onChange,
+      onOptionChecked: this.tt.onOptionChecked,
+      option: option,
+      optionIndex: index,
+      options: this.props.options,
+      wrapperOpts: this.tt.wrapperOpts
+    })));
+  }
+  inputDefaultValue() {
+    const {
+      attribute,
+      defaultValue,
+      model
+    } = this.props;
+    if (defaultValue) {
+      return defaultValue;
+    } else if (attribute && model) {
+      if (!model[attribute]) throw `No such attribute: ${attribute}`;
+      return this.props.model[attribute]();
+    }
+  }
+  inputCheckboxClassName() {
+    const classNames = [];
+    if (this.tt.wrapperOpts.errors.length > 0) classNames.push("is-invalid");
+    return classNames.join(" ");
+  }
+  inputName() {
+    if (this.props.name) {
+      return `${this.props.name}[]`;
+    } else if (this.props.model) {
+      return `${this.props.model.modelClassData().paramKey}[${inflection.underscore(this.props.attribute)}]`;
+    }
+  }
+  isDefaultSelected(option) {
+    let defaultValue = this.inputDefaultValue();
+    if (!defaultValue) return false;
+    if (defaultValue.constructor === Array) {
+      return defaultValue.includes(option);
+    } else {
+      return defaultValue == option;
+    }
+  }
+  labelClassName() {
+    const classNames = [];
+    if (this.props.labelClassName) classNames.push(this.props.labelClassName);
+    return classNames.join(" ");
+  }
+  onOptionChecked = ({
+    event,
+    option
+  }) => {
+    const {
+      inputProps,
+      form
+    } = this.tt;
+    const {
+      name
+    } = inputProps;
+    const checked = event.target.checked;
+    let newOptions;
+    if (checked) {
+      newOptions = this.s.checkedOptions.concat([option[1]]);
+      this.setState({
+        checkedOptions: newOptions
+      });
+    } else {
+      newOptions = this.s.checkedOptions.filter(value => value != option[1]);
+      this.setState({
+        checkedOptions: newOptions
+      });
+    }
+    if (form && name) {
+      form.setValue(name, newOptions);
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shapeComponent","ShapeComponent","React","useMemo","digs","useForm","inflection","InvalidFeedback","memo","PropTypes","propTypesExact","useInput","OptionElement","render","generatedId","inputCheckboxClassName","isDefaultSelected","inputName","option","optionIndex","options","wrapperOpts","p","errors","id","createElement","className","key","defaultChecked","name","onChange","tt","type","value","htmlFor","length","event","restProps","onOptionChecked","props","ApiMakerBootstrapCheckboxes","propTypes","attribute","string","defaultValue","array","label","labelClassName","model","object","func","isRequired","setup","inputProps","Math","random","toString","substring","setInstance","form","useStates","checkedOptions","Array","isArray","setValue","s","ref","map","index","inputDefaultValue","classNames","push","join","modelClassData","paramKey","underscore","constructor","includes","checked","target","newOptions","concat","setState","filter"],"sources":["../../src/bootstrap/checkboxes.jsx"],"sourcesContent":["import {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport React, {useMemo} from \"react\"\nimport {digs} from \"diggerize\"\nimport {useForm} from \"../form\"\nimport * as inflection from \"inflection\"\nimport InvalidFeedback from \"./invalid-feedback\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport useInput from \"../use-input\"\n\nconst OptionElement = memo(shapeComponent(class OptionElement extends ShapeComponent {\n  render() {\n    const {generatedId, inputCheckboxClassName, isDefaultSelected, inputName, option, optionIndex, options, wrapperOpts} = this.p\n    const {errors} = digs(wrapperOpts, \"errors\")\n    const id = `${generatedId}-${optionIndex}`\n\n    return (\n      <div className=\"checkboxes-option\" key={`option-${option[1]}`}>\n        <input\n          className={inputCheckboxClassName}\n          data-option-value={option[1]}\n          defaultChecked={isDefaultSelected}\n          id={id}\n          name={inputName}\n          onChange={this.tt.onChange}\n          type=\"checkbox\"\n          value={option[1]}\n        />\n\n        <label className=\"ml-1\" htmlFor={id}>\n          {option[0]}\n        </label>\n\n        {(optionIndex + 1) == options.length && errors.length > 0 &&\n          <InvalidFeedback errors={errors} />\n        }\n      </div>\n    )\n  }\n\n  onChange = (event, ...restProps) => {\n    this.p.onOptionChecked({event, option: this.p.option})\n\n    if (this.props.onChange) this.props.onChange(event, ...restProps)\n  }\n}))\n\nexport default memo(shapeComponent(class ApiMakerBootstrapCheckboxes extends ShapeComponent {\n  static propTypes = propTypesExact({\n    attribute: PropTypes.string,\n    defaultValue: PropTypes.array,\n    label: PropTypes.string,\n    labelClassName: PropTypes.string,\n    model: PropTypes.object,\n    name: PropTypes.string,\n    onChange: PropTypes.func,\n    options: PropTypes.array.isRequired\n  })\n\n  setup() {\n    const {inputProps, wrapperOpts} = useInput({props: this.props})\n\n    this.generatedId = useMemo(\n      () => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),\n      []\n    )\n\n    this.setInstance({\n      form: useForm(),\n      inputProps,\n      wrapperOpts\n    })\n    this.useStates({\n      checkedOptions: () => {\n        if (Array.isArray(this.props.defaultValue)) return this.props.defaultValue\n        if (this.props.defaultValue) return [this.props.defaultValue]\n\n        return []\n      }\n    })\n\n    useMemo(() => {\n      if (this.form && inputProps.name) {\n        this.form.setValue(inputProps.name, this.s.checkedOptions)\n      }\n    }, [])\n  }\n\n  render () {\n    return (\n      <div className=\"component-bootstrap-checkboxes form-group\">\n        <label className={this.labelClassName()}>\n          {this.tt.wrapperOpts.label}\n        </label>\n\n        <input name={this.inputName()} ref={this.tt.inputProps.ref} type=\"hidden\" value=\"\" />\n        {this.props.options.map((option, index) =>\n          <OptionElement\n            inputCheckboxClassName={this.tt.inputCheckboxClassName()}\n            inputName={this.inputName()}\n            isDefaultSelected={this.isDefaultSelected(option[1])}\n            generatedId={this.tt.generatedId}\n            key={option[1]}\n            onChange={this.props.onChange}\n            onOptionChecked={this.tt.onOptionChecked}\n            option={option}\n            optionIndex={index}\n            options={this.props.options}\n            wrapperOpts={this.tt.wrapperOpts}\n          />\n        )}\n      </div>\n    )\n  }\n\n  inputDefaultValue () {\n    const {attribute, defaultValue, model} = this.props\n\n    if (defaultValue) {\n      return defaultValue\n    } else if (attribute && model) {\n      if (!model[attribute]) throw `No such attribute: ${attribute}`\n\n      return this.props.model[attribute]()\n    }\n  }\n\n  inputCheckboxClassName () {\n    const classNames = []\n\n    if (this.tt.wrapperOpts.errors.length > 0) classNames.push(\"is-invalid\")\n\n    return classNames.join(\" \")\n  }\n\n  inputName () {\n    if (this.props.name) {\n      return `${this.props.name}[]`\n    } else if (this.props.model) {\n      return `${this.props.model.modelClassData().paramKey}[${inflection.underscore(this.props.attribute)}]`\n    }\n  }\n\n  isDefaultSelected (option) {\n    let defaultValue = this.inputDefaultValue()\n\n    if (!defaultValue) return false\n\n    if (defaultValue.constructor === Array) {\n      return defaultValue.includes(option)\n    } else {\n      return defaultValue == option\n    }\n  }\n\n  labelClassName () {\n    const classNames = []\n\n    if (this.props.labelClassName) classNames.push(this.props.labelClassName)\n\n    return classNames.join(\" \")\n  }\n\n  onOptionChecked = ({event, option}) => {\n    const {inputProps, form} = this.tt\n    const {name} = inputProps\n    const checked = event.target.checked\n    let newOptions\n\n    if (checked) {\n      newOptions = this.s.checkedOptions.concat([option[1]])\n\n      this.setState({checkedOptions: newOptions})\n    } else {\n      newOptions = this.s.checkedOptions.filter((value) => value != option[1])\n\n      this.setState({checkedOptions: newOptions})\n    }\n\n    if (form && name) {\n      form.setValue(name, newOptions)\n    }\n  }\n}))\n"],"mappings":"AAAA,SAAQA,cAAc,EAAEC,cAAc,QAAO,uCAAuC;AACpF,OAAOC,KAAK,IAAGC,OAAO,QAAO,OAAO;AACpC,SAAQC,IAAI,QAAO,WAAW;AAC9B,SAAQC,OAAO,QAAO,SAAS;AAC/B,OAAO,KAAKC,UAAU,MAAM,YAAY;AACxC,OAAOC,eAAe,MAAM,oBAAoB;AAChD,OAAOC,IAAI,MAAM,4BAA4B;AAC7C,OAAOC,SAAS,MAAM,YAAY;AAClC,OAAOC,cAAc,MAAM,kBAAkB;AAC7C,OAAOC,QAAQ,MAAM,cAAc;AAEnC,MAAMC,aAAa,GAAGJ,IAAI,CAACR,cAAc,CAAC,MAAMY,aAAa,SAASX,cAAc,CAAC;EACnFY,MAAMA,CAAA,EAAG;IACP,MAAM;MAACC,WAAW;MAAEC,sBAAsB;MAAEC,iBAAiB;MAAEC,SAAS;MAAEC,MAAM;MAAEC,WAAW;MAAEC,OAAO;MAAEC;IAAW,CAAC,GAAG,IAAI,CAACC,CAAC;IAC7H,MAAM;MAACC;IAAM,CAAC,GAAGnB,IAAI,CAACiB,WAAW,EAAE,QAAQ,CAAC;IAC5C,MAAMG,EAAE,GAAG,GAAGV,WAAW,IAAIK,WAAW,EAAE;IAE1C,oBACEjB,KAAA,CAAAuB,aAAA;MAAKC,SAAS,EAAC,mBAAmB;MAACC,GAAG,EAAE,UAAUT,MAAM,CAAC,CAAC,CAAC;IAAG,gBAC5DhB,KAAA,CAAAuB,aAAA;MACEC,SAAS,EAAEX,sBAAuB;MAClC,qBAAmBG,MAAM,CAAC,CAAC,CAAE;MAC7BU,cAAc,EAAEZ,iBAAkB;MAClCQ,EAAE,EAAEA,EAAG;MACPK,IAAI,EAAEZ,SAAU;MAChBa,QAAQ,EAAE,IAAI,CAACC,EAAE,CAACD,QAAS;MAC3BE,IAAI,EAAC,UAAU;MACfC,KAAK,EAAEf,MAAM,CAAC,CAAC;IAAE,CAClB,CAAC,eAEFhB,KAAA,CAAAuB,aAAA;MAAOC,SAAS,EAAC,MAAM;MAACQ,OAAO,EAAEV;IAAG,GACjCN,MAAM,CAAC,CAAC,CACJ,CAAC,EAENC,WAAW,GAAG,CAAC,IAAKC,OAAO,CAACe,MAAM,IAAIZ,MAAM,CAACY,MAAM,GAAG,CAAC,iBACvDjC,KAAA,CAAAuB,aAAA,CAAClB,eAAe;MAACgB,MAAM,EAAEA;IAAO,CAAE,CAEjC,CAAC;EAEV;EAEAO,QAAQ,GAAGA,CAACM,KAAK,EAAE,GAAGC,SAAS,KAAK;IAClC,IAAI,CAACf,CAAC,CAACgB,eAAe,CAAC;MAACF,KAAK;MAAElB,MAAM,EAAE,IAAI,CAACI,CAAC,CAACJ;IAAM,CAAC,CAAC;IAEtD,IAAI,IAAI,CAACqB,KAAK,CAACT,QAAQ,EAAE,IAAI,CAACS,KAAK,CAACT,QAAQ,CAACM,KAAK,EAAE,GAAGC,SAAS,CAAC;EACnE,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,eAAe7B,IAAI,CAACR,cAAc,CAAC,MAAMwC,2BAA2B,SAASvC,cAAc,CAAC;EAC1F,OAAOwC,SAAS,GAAG/B,cAAc,CAAC;IAChCgC,SAAS,EAAEjC,SAAS,CAACkC,MAAM;IAC3BC,YAAY,EAAEnC,SAAS,CAACoC,KAAK;IAC7BC,KAAK,EAAErC,SAAS,CAACkC,MAAM;IACvBI,cAAc,EAAEtC,SAAS,CAACkC,MAAM;IAChCK,KAAK,EAAEvC,SAAS,CAACwC,MAAM;IACvBpB,IAAI,EAAEpB,SAAS,CAACkC,MAAM;IACtBb,QAAQ,EAAErB,SAAS,CAACyC,IAAI;IACxB9B,OAAO,EAAEX,SAAS,CAACoC,KAAK,CAACM;EAC3B,CAAC,CAAC;EAEFC,KAAKA,CAAA,EAAG;IACN,MAAM;MAACC,UAAU;MAAEhC;IAAW,CAAC,GAAGV,QAAQ,CAAC;MAAC4B,KAAK,EAAE,IAAI,CAACA;IAAK,CAAC,CAAC;IAE/D,IAAI,CAACzB,WAAW,GAAGX,OAAO,CACxB,MAAMmD,IAAI,CAACC,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC,CAACC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAGH,IAAI,CAACC,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC,CAACC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAC/F,EACF,CAAC;IAED,IAAI,CAACC,WAAW,CAAC;MACfC,IAAI,EAAEtD,OAAO,CAAC,CAAC;MACfgD,UAAU;MACVhC;IACF,CAAC,CAAC;IACF,IAAI,CAACuC,SAAS,CAAC;MACbC,cAAc,EAAEA,CAAA,KAAM;QACpB,IAAIC,KAAK,CAACC,OAAO,CAAC,IAAI,CAACxB,KAAK,CAACK,YAAY,CAAC,EAAE,OAAO,IAAI,CAACL,KAAK,CAACK,YAAY;QAC1E,IAAI,IAAI,CAACL,KAAK,CAACK,YAAY,EAAE,OAAO,CAAC,IAAI,CAACL,KAAK,CAACK,YAAY,CAAC;QAE7D,OAAO,EAAE;MACX;IACF,CAAC,CAAC;IAEFzC,OAAO,CAAC,MAAM;MACZ,IAAI,IAAI,CAACwD,IAAI,IAAIN,UAAU,CAACxB,IAAI,EAAE;QAChC,IAAI,CAAC8B,IAAI,CAACK,QAAQ,CAACX,UAAU,CAACxB,IAAI,EAAE,IAAI,CAACoC,CAAC,CAACJ,cAAc,CAAC;MAC5D;IACF,CAAC,EAAE,EAAE,CAAC;EACR;EAEAhD,MAAMA,CAAA,EAAI;IACR,oBACEX,KAAA,CAAAuB,aAAA;MAAKC,SAAS,EAAC;IAA2C,gBACxDxB,KAAA,CAAAuB,aAAA;MAAOC,SAAS,EAAE,IAAI,CAACqB,cAAc,CAAC;IAAE,GACrC,IAAI,CAAChB,EAAE,CAACV,WAAW,CAACyB,KAChB,CAAC,eAER5C,KAAA,CAAAuB,aAAA;MAAOI,IAAI,EAAE,IAAI,CAACZ,SAAS,CAAC,CAAE;MAACiD,GAAG,EAAE,IAAI,CAACnC,EAAE,CAACsB,UAAU,CAACa,GAAI;MAAClC,IAAI,EAAC,QAAQ;MAACC,KAAK,EAAC;IAAE,CAAE,CAAC,EACpF,IAAI,CAACM,KAAK,CAACnB,OAAO,CAAC+C,GAAG,CAAC,CAACjD,MAAM,EAAEkD,KAAK,kBACpClE,KAAA,CAAAuB,aAAA,CAACb,aAAa;MACZG,sBAAsB,EAAE,IAAI,CAACgB,EAAE,CAAChB,sBAAsB,CAAC,CAAE;MACzDE,SAAS,EAAE,IAAI,CAACA,SAAS,CAAC,CAAE;MAC5BD,iBAAiB,EAAE,IAAI,CAACA,iBAAiB,CAACE,MAAM,CAAC,CAAC,CAAC,CAAE;MACrDJ,WAAW,EAAE,IAAI,CAACiB,EAAE,CAACjB,WAAY;MACjCa,GAAG,EAAET,MAAM,CAAC,CAAC,CAAE;MACfY,QAAQ,EAAE,IAAI,CAACS,KAAK,CAACT,QAAS;MAC9BQ,eAAe,EAAE,IAAI,CAACP,EAAE,CAACO,eAAgB;MACzCpB,MAAM,EAAEA,MAAO;MACfC,WAAW,EAAEiD,KAAM;MACnBhD,OAAO,EAAE,IAAI,CAACmB,KAAK,CAACnB,OAAQ;MAC5BC,WAAW,EAAE,IAAI,CAACU,EAAE,CAACV;IAAY,CAClC,CACH,CACG,CAAC;EAEV;EAEAgD,iBAAiBA,CAAA,EAAI;IACnB,MAAM;MAAC3B,SAAS;MAAEE,YAAY;MAAEI;IAAK,CAAC,GAAG,IAAI,CAACT,KAAK;IAEnD,IAAIK,YAAY,EAAE;MAChB,OAAOA,YAAY;IACrB,CAAC,MAAM,IAAIF,SAAS,IAAIM,KAAK,EAAE;MAC7B,IAAI,CAACA,KAAK,CAACN,SAAS,CAAC,EAAE,MAAM,sBAAsBA,SAAS,EAAE;MAE9D,OAAO,IAAI,CAACH,KAAK,CAACS,KAAK,CAACN,SAAS,CAAC,CAAC,CAAC;IACtC;EACF;EAEA3B,sBAAsBA,CAAA,EAAI;IACxB,MAAMuD,UAAU,GAAG,EAAE;IAErB,IAAI,IAAI,CAACvC,EAAE,CAACV,WAAW,CAACE,MAAM,CAACY,MAAM,GAAG,CAAC,EAAEmC,UAAU,CAACC,IAAI,CAAC,YAAY,CAAC;IAExE,OAAOD,UAAU,CAACE,IAAI,CAAC,GAAG,CAAC;EAC7B;EAEAvD,SAASA,CAAA,EAAI;IACX,IAAI,IAAI,CAACsB,KAAK,CAACV,IAAI,EAAE;MACnB,OAAO,GAAG,IAAI,CAACU,KAAK,CAACV,IAAI,IAAI;IAC/B,CAAC,MAAM,IAAI,IAAI,CAACU,KAAK,CAACS,KAAK,EAAE;MAC3B,OAAO,GAAG,IAAI,CAACT,KAAK,CAACS,KAAK,CAACyB,cAAc,CAAC,CAAC,CAACC,QAAQ,IAAIpE,UAAU,CAACqE,UAAU,CAAC,IAAI,CAACpC,KAAK,CAACG,SAAS,CAAC,GAAG;IACxG;EACF;EAEA1B,iBAAiBA,CAAEE,MAAM,EAAE;IACzB,IAAI0B,YAAY,GAAG,IAAI,CAACyB,iBAAiB,CAAC,CAAC;IAE3C,IAAI,CAACzB,YAAY,EAAE,OAAO,KAAK;IAE/B,IAAIA,YAAY,CAACgC,WAAW,KAAKd,KAAK,EAAE;MACtC,OAAOlB,YAAY,CAACiC,QAAQ,CAAC3D,MAAM,CAAC;IACtC,CAAC,MAAM;MACL,OAAO0B,YAAY,IAAI1B,MAAM;IAC/B;EACF;EAEA6B,cAAcA,CAAA,EAAI;IAChB,MAAMuB,UAAU,GAAG,EAAE;IAErB,IAAI,IAAI,CAAC/B,KAAK,CAACQ,cAAc,EAAEuB,UAAU,CAACC,IAAI,CAAC,IAAI,CAAChC,KAAK,CAACQ,cAAc,CAAC;IAEzE,OAAOuB,UAAU,CAACE,IAAI,CAAC,GAAG,CAAC;EAC7B;EAEAlC,eAAe,GAAGA,CAAC;IAACF,KAAK;IAAElB;EAAM,CAAC,KAAK;IACrC,MAAM;MAACmC,UAAU;MAAEM;IAAI,CAAC,GAAG,IAAI,CAAC5B,EAAE;IAClC,MAAM;MAACF;IAAI,CAAC,GAAGwB,UAAU;IACzB,MAAMyB,OAAO,GAAG1C,KAAK,CAAC2C,MAAM,CAACD,OAAO;IACpC,IAAIE,UAAU;IAEd,IAAIF,OAAO,EAAE;MACXE,UAAU,GAAG,IAAI,CAACf,CAAC,CAACJ,cAAc,CAACoB,MAAM,CAAC,CAAC/D,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;MAEtD,IAAI,CAACgE,QAAQ,CAAC;QAACrB,cAAc,EAAEmB;MAAU,CAAC,CAAC;IAC7C,CAAC,MAAM;MACLA,UAAU,GAAG,IAAI,CAACf,CAAC,CAACJ,cAAc,CAACsB,MAAM,CAAElD,KAAK,IAAKA,KAAK,IAAIf,MAAM,CAAC,CAAC,CAAC,CAAC;MAExE,IAAI,CAACgE,QAAQ,CAAC;QAACrB,cAAc,EAAEmB;MAAU,CAAC,CAAC;IAC7C;IAEA,IAAIrB,IAAI,IAAI9B,IAAI,EAAE;MAChB8B,IAAI,CAACK,QAAQ,CAACnC,IAAI,EAAEmD,UAAU,CAAC;IACjC;EACF,CAAC;AACH,CAAC,CAAC,CAAC","ignoreList":[]}

package/build/bootstrap/index.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jvb3RzdHJhcC9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyIiXSwibWFwcGluZ3MiOiIiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/bootstrap/input.js

@@ -0,0 +1,129 @@
+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 { digs } from "diggerize";
+import inputWrapper from "../inputs/input-wrapper";
+import { Input } from "../inputs/input";
+import InvalidFeedback from "./invalid-feedback";
+import memo from "set-state-compare/src/memo";
+import Money from "../inputs/money";
+import PropTypes from "prop-types";
+import React from "react";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+const ApiMakerBootstrapInput = memo(shapeComponent(class ApiMakerBootstrapInput extends ShapeComponent {
+  static propTypes = {
+    append: PropTypes.node,
+    appendText: PropTypes.node,
+    attribute: PropTypes.string,
+    className: PropTypes.string,
+    currenciesCollection: PropTypes.array,
+    currencyName: PropTypes.string,
+    hint: PropTypes.node,
+    hintBottom: PropTypes.node,
+    id: PropTypes.string,
+    label: PropTypes.node,
+    labelClassName: PropTypes.string,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    placeholder: PropTypes.node,
+    prepend: PropTypes.node,
+    prependText: PropTypes.node,
+    small: PropTypes.bool,
+    type: PropTypes.string,
+    wrapperClassName: PropTypes.string
+  };
+  render() {
+    const {
+      append,
+      appendText,
+      attribute,
+      className,
+      currenciesCollection,
+      currencyName,
+      hint,
+      hintBottom,
+      id,
+      inputClassName,
+      inputProps,
+      inputRef,
+      label,
+      labelClassName,
+      model,
+      name,
+      prepend,
+      prependText,
+      type,
+      wrapperClassName,
+      wrapperOpts,
+      ...restProps
+    } = this.props;
+    const {
+      ref,
+      ...forwardedInputProps
+    } = inputProps;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    return /*#__PURE__*/React.createElement("div", {
+      className: this.wrapperClassName(),
+      ref: this.props.wrapperRef
+    }, wrapperOpts.label && /*#__PURE__*/React.createElement("label", {
+      className: this.labelClassName(),
+      htmlFor: inputProps.id
+    }, wrapperOpts.label), hint && /*#__PURE__*/React.createElement("span", {
+      className: "form-text text-muted font-smoothing font-xs"
+    }, hint), type == "money" && /*#__PURE__*/React.createElement(Money, _extends({
+      name: inputProps.name,
+      className: this.inputClassName(),
+      ref: this.props.moneyRef
+    }, this.moneyProps())), type != "money" && /*#__PURE__*/React.createElement("div", {
+      className: "input-group"
+    }, (prepend || prependText) && /*#__PURE__*/React.createElement("div", {
+      className: "input-group-prepend"
+    }, prependText && /*#__PURE__*/React.createElement("span", {
+      className: "input-group-text"
+    }, prependText), prepend), /*#__PURE__*/React.createElement(Input, _extends({
+      attribute: attribute,
+      className: this.inputClassName(),
+      inputProps: inputProps,
+      model: model,
+      wrapperOpts: wrapperOpts
+    }, forwardedInputProps, restProps)), (append || appendText) && /*#__PURE__*/React.createElement("div", {
+      className: "input-group-append"
+    }, appendText && /*#__PURE__*/React.createElement("span", {
+      className: "input-group-text"
+    }, appendText), append), errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    })), hintBottom && /*#__PURE__*/React.createElement("span", {
+      className: "form-text text-muted font-smoothing font-xs"
+    }, hintBottom));
+  }
+  inputClassName() {
+    const classNames = ["form-control"];
+    if (this.props.className) classNames.push(this.props.className);
+    if (this.props.wrapperOpts.errors.length > 0) classNames.push("is-invalid");
+    return classNames.join(" ");
+  }
+  labelClassName() {
+    const classNames = [];
+    if (this.props.labelClassName) classNames.push(this.props.labelClassName);
+    return classNames.join(" ");
+  }
+  moneyProps() {
+    const moneyProps = {};
+    const forwardedProps = ["attribute", "currenciesCollection", "currencyName", "model", "onChange", "placeholder", "small"];
+    for (const forwardedProp of forwardedProps) {
+      if (forwardedProp in this.props) moneyProps[forwardedProp] = this.props[forwardedProp];
+    }
+    const forwardedInputProps = ["defaultValue"];
+    for (const forwardedInputProp of forwardedInputProps) {
+      if (forwardedInputProp in this.props.inputProps) moneyProps[forwardedInputProp] = this.props.inputProps[forwardedInputProp];
+    }
+    return moneyProps;
+  }
+  wrapperClassName() {
+    const classNames = ["form-group", "component-bootstrap-string-input"];
+    if (this.props.wrapperClassName) classNames.push(this.props.wrapperClassName);
+    return classNames.join(" ");
+  }
+}));
+export default inputWrapper(ApiMakerBootstrapInput);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digs","inputWrapper","Input","InvalidFeedback","memo","Money","PropTypes","React","shapeComponent","ShapeComponent","ApiMakerBootstrapInput","propTypes","append","node","appendText","attribute","string","className","currenciesCollection","array","currencyName","hint","hintBottom","id","label","labelClassName","model","object","name","placeholder","prepend","prependText","small","bool","type","wrapperClassName","render","inputClassName","inputProps","inputRef","wrapperOpts","restProps","props","ref","forwardedInputProps","errors","createElement","wrapperRef","htmlFor","_extends","moneyRef","moneyProps","length","classNames","push","join","forwardedProps","forwardedProp","forwardedInputProp"],"sources":["../../src/bootstrap/input.jsx"],"sourcesContent":["import {digs} from \"diggerize\"\nimport inputWrapper from \"../inputs/input-wrapper\"\nimport {Input} from \"../inputs/input\"\nimport InvalidFeedback from \"./invalid-feedback\"\nimport memo from \"set-state-compare/src/memo\"\nimport Money from \"../inputs/money\"\nimport PropTypes from \"prop-types\"\nimport React from \"react\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\n\nconst ApiMakerBootstrapInput = memo(shapeComponent(class ApiMakerBootstrapInput extends ShapeComponent {\n  static propTypes = {\n    append: PropTypes.node,\n    appendText: PropTypes.node,\n    attribute: PropTypes.string,\n    className: PropTypes.string,\n    currenciesCollection: PropTypes.array,\n    currencyName: PropTypes.string,\n    hint: PropTypes.node,\n    hintBottom: PropTypes.node,\n    id: PropTypes.string,\n    label: PropTypes.node,\n    labelClassName: PropTypes.string,\n    model: PropTypes.object,\n    name: PropTypes.string,\n    placeholder: PropTypes.node,\n    prepend: PropTypes.node,\n    prependText: PropTypes.node,\n    small: PropTypes.bool,\n    type: PropTypes.string,\n    wrapperClassName: PropTypes.string\n  }\n\n  render () {\n    const {\n      append,\n      appendText,\n      attribute,\n      className,\n      currenciesCollection,\n      currencyName,\n      hint,\n      hintBottom,\n      id,\n      inputClassName,\n      inputProps,\n      inputRef,\n      label,\n      labelClassName,\n      model,\n      name,\n      prepend,\n      prependText,\n      type,\n      wrapperClassName,\n      wrapperOpts,\n      ...restProps\n    } = this.props\n    const {ref, ...forwardedInputProps} = inputProps\n    const {errors} = digs(wrapperOpts, \"errors\")\n\n    return (\n      <div className={this.wrapperClassName()} ref={this.props.wrapperRef}>\n        {wrapperOpts.label &&\n          <label className={this.labelClassName()} htmlFor={inputProps.id}>\n            {wrapperOpts.label}\n          </label>\n        }\n        {hint &&\n          <span className=\"form-text text-muted font-smoothing font-xs\">\n            {hint}\n          </span>\n        }\n        {type == \"money\" &&\n          <Money\n            name={inputProps.name}\n            className={this.inputClassName()}\n            ref={this.props.moneyRef}\n            {...this.moneyProps()}\n          />\n        }\n        {type != \"money\" &&\n          <div className=\"input-group\">\n            {(prepend || prependText) &&\n              <div className=\"input-group-prepend\">\n                {prependText &&\n                  <span className=\"input-group-text\">\n                    {prependText}\n                  </span>\n                }\n                {prepend}\n              </div>\n            }\n            <Input\n              attribute={attribute}\n              className={this.inputClassName()}\n              inputProps={inputProps}\n              model={model}\n              wrapperOpts={wrapperOpts}\n              {...forwardedInputProps}\n              {...restProps}\n            />\n            {(append || appendText) &&\n              <div className=\"input-group-append\">\n                {appendText &&\n                  <span className=\"input-group-text\">\n                    {appendText}\n                  </span>\n                }\n                {append}\n              </div>\n            }\n            {errors.length > 0 && <InvalidFeedback errors={errors} />}\n          </div>\n        }\n        {hintBottom &&\n          <span className=\"form-text text-muted font-smoothing font-xs\">\n            {hintBottom}\n          </span>\n        }\n      </div>\n    )\n  }\n\n  inputClassName () {\n    const classNames = [\"form-control\"]\n\n    if (this.props.className)\n      classNames.push(this.props.className)\n\n    if (this.props.wrapperOpts.errors.length > 0)\n      classNames.push(\"is-invalid\")\n\n    return classNames.join(\" \")\n  }\n\n  labelClassName () {\n    const classNames = []\n\n    if (this.props.labelClassName)\n      classNames.push(this.props.labelClassName)\n\n    return classNames.join(\" \")\n  }\n\n  moneyProps() {\n    const moneyProps = {}\n    const forwardedProps = [\"attribute\", \"currenciesCollection\", \"currencyName\", \"model\", \"onChange\", \"placeholder\", \"small\"]\n\n    for (const forwardedProp of forwardedProps) {\n      if (forwardedProp in this.props) moneyProps[forwardedProp] = this.props[forwardedProp]\n    }\n\n    const forwardedInputProps = [\"defaultValue\"]\n\n    for (const forwardedInputProp of forwardedInputProps) {\n      if (forwardedInputProp in this.props.inputProps) moneyProps[forwardedInputProp] = this.props.inputProps[forwardedInputProp]\n    }\n\n    return moneyProps\n  }\n\n  wrapperClassName () {\n    const classNames = [\"form-group\", \"component-bootstrap-string-input\"]\n\n    if (this.props.wrapperClassName)\n      classNames.push(this.props.wrapperClassName)\n\n    return classNames.join(\" \")\n  }\n}))\n\nexport default inputWrapper(ApiMakerBootstrapInput)\n"],"mappings":"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","ignoreList":[]}

package/build/bootstrap/invalid-feedback.js

@@ -0,0 +1,27 @@
+import { digs } from "diggerize";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerBootstrapInvalidFeedback extends React.PureComponent {
+  static propTypes = propTypesExact({
+    errors: PropTypes.array.isRequired
+  });
+  render() {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "invalid-feedback"
+    }, this.errorMessages().join(". "));
+  }
+  errorMessages() {
+    const {
+      errors
+    } = digs(this.props, "errors");
+    const errorMessages = [];
+    for (const error of errors) {
+      for (const errorMessage of error.getErrorMessages()) {
+        errorMessages.push(errorMessage);
+      }
+    }
+    return errorMessages;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdzIiwiUHJvcFR5cGVzIiwicHJvcFR5cGVzRXhhY3QiLCJSZWFjdCIsIkFwaU1ha2VyQm9vdHN0cmFwSW52YWxpZEZlZWRiYWNrIiwiUHVyZUNvbXBvbmVudCIsInByb3BUeXBlcyIsImVycm9ycyIsImFycmF5IiwiaXNSZXF1aXJlZCIsInJlbmRlciIsImNyZWF0ZUVsZW1lbnQiLCJjbGFzc05hbWUiLCJlcnJvck1lc3NhZ2VzIiwiam9pbiIsInByb3BzIiwiZXJyb3IiLCJlcnJvck1lc3NhZ2UiLCJnZXRFcnJvck1lc3NhZ2VzIiwicHVzaCJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ib290c3RyYXAvaW52YWxpZC1mZWVkYmFjay5qc3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtkaWdzfSBmcm9tIFwiZGlnZ2VyaXplXCJcbmltcG9ydCBQcm9wVHlwZXMgZnJvbSBcInByb3AtdHlwZXNcIlxuaW1wb3J0IHByb3BUeXBlc0V4YWN0IGZyb20gXCJwcm9wLXR5cGVzLWV4YWN0XCJcbmltcG9ydCBSZWFjdCBmcm9tIFwicmVhY3RcIlxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBBcGlNYWtlckJvb3RzdHJhcEludmFsaWRGZWVkYmFjayBleHRlbmRzIFJlYWN0LlB1cmVDb21wb25lbnQge1xuICBzdGF0aWMgcHJvcFR5cGVzID0gcHJvcFR5cGVzRXhhY3Qoe1xuICAgIGVycm9yczogUHJvcFR5cGVzLmFycmF5LmlzUmVxdWlyZWRcbiAgfSlcblxuICByZW5kZXIgKCkge1xuICAgIHJldHVybiAoXG4gICAgICA8ZGl2IGNsYXNzTmFtZT1cImludmFsaWQtZmVlZGJhY2tcIj5cbiAgICAgICAge3RoaXMuZXJyb3JNZXNzYWdlcygpLmpvaW4oXCIuIFwiKX1cbiAgICAgIDwvZGl2PlxuICAgIClcbiAgfVxuXG4gIGVycm9yTWVzc2FnZXMgKCkge1xuICAgIGNvbnN0IHtlcnJvcnN9ID0gZGlncyh0aGlzLnByb3BzLCBcImVycm9yc1wiKVxuICAgIGNvbnN0IGVycm9yTWVzc2FnZXMgPSBbXVxuXG4gICAgZm9yIChjb25zdCBlcnJvciBvZiBlcnJvcnMpIHtcbiAgICAgIGZvciAoY29uc3QgZXJyb3JNZXNzYWdlIG9mIGVycm9yLmdldEVycm9yTWVzc2FnZXMoKSkge1xuICAgICAgICBlcnJvck1lc3NhZ2VzLnB1c2goZXJyb3JNZXNzYWdlKVxuICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBlcnJvck1lc3NhZ2VzXG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsSUFBSSxRQUFPLFdBQVc7QUFDOUIsT0FBT0MsU0FBUyxNQUFNLFlBQVk7QUFDbEMsT0FBT0MsY0FBYyxNQUFNLGtCQUFrQjtBQUM3QyxPQUFPQyxLQUFLLE1BQU0sT0FBTztBQUV6QixlQUFlLE1BQU1DLGdDQUFnQyxTQUFTRCxLQUFLLENBQUNFLGFBQWEsQ0FBQztFQUNoRixPQUFPQyxTQUFTLEdBQUdKLGNBQWMsQ0FBQztJQUNoQ0ssTUFBTSxFQUFFTixTQUFTLENBQUNPLEtBQUssQ0FBQ0M7RUFDMUIsQ0FBQyxDQUFDO0VBRUZDLE1BQU1BLENBQUEsRUFBSTtJQUNSLG9CQUNFUCxLQUFBLENBQUFRLGFBQUE7TUFBS0MsU0FBUyxFQUFDO0lBQWtCLEdBQzlCLElBQUksQ0FBQ0MsYUFBYSxDQUFDLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLElBQUksQ0FDNUIsQ0FBQztFQUVWO0VBRUFELGFBQWFBLENBQUEsRUFBSTtJQUNmLE1BQU07TUFBQ047SUFBTSxDQUFDLEdBQUdQLElBQUksQ0FBQyxJQUFJLENBQUNlLEtBQUssRUFBRSxRQUFRLENBQUM7SUFDM0MsTUFBTUYsYUFBYSxHQUFHLEVBQUU7SUFFeEIsS0FBSyxNQUFNRyxLQUFLLElBQUlULE1BQU0sRUFBRTtNQUMxQixLQUFLLE1BQU1VLFlBQVksSUFBSUQsS0FBSyxDQUFDRSxnQkFBZ0IsQ0FBQyxDQUFDLEVBQUU7UUFDbkRMLGFBQWEsQ0FBQ00sSUFBSSxDQUFDRixZQUFZLENBQUM7TUFDbEM7SUFDRjtJQUVBLE9BQU9KLGFBQWE7RUFDdEI7QUFDRiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/bootstrap/paginate.js

@@ -0,0 +1,150 @@
+import BaseComponent from "../base-component";
+import instanceOfClassName from "../instance-of-class-name";
+import Link from "../link";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import memo from "set-state-compare/src/memo";
+import qs from "qs";
+import React, { useMemo } from "react";
+import Text from "../utils/text";
+import Result from "../result";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import urlEncode from "../url-encode";
+export default memo(shapeComponent(class ApiMakerBootstrapPaginate extends BaseComponent {
+  static propTypes = propTypesExact({
+    result: PropTypes.oneOfType([instanceOfClassName("ApiMakerResult"), PropTypes.instanceOf(Result)]).isRequired
+  });
+  setup() {
+    const {
+      result
+    } = this.p;
+    this.totalPages = useMemo(() => Math.ceil(result.count() / result.perPage()), [result.count(), result.perPage()]);
+    this.pages = useMemo(() => this.calculatePages(), [result.currentPage(), this.totalPages]);
+  }
+  calculatePages() {
+    const {
+      result
+    } = this.p;
+    const {
+      totalPages
+    } = this.tt;
+    const currentPage = result.currentPage();
+    const pages = [];
+    let pagesFrom = currentPage - 5;
+    let pagesTo = currentPage + 5;
+    if (pagesFrom < 1) {
+      pagesFrom = 1;
+    }
+    if (pagesTo > totalPages) {
+      pagesTo = totalPages;
+    }
+    for (let i = pagesFrom; i <= pagesTo; i++) {
+      pages.push(i);
+    }
+    return pages;
+  }
+  isPageActiveClass = pageNumber => this.p.result.currentPage() == pageNumber ? "active" : "not-active";
+  pagePath(pageNumber) {
+    let pageKey = this.p.result.data.collection.queryArgs.pageKey;
+    if (!pageKey) {
+      pageKey = "page";
+    }
+    const currentParams = qs.parse(globalThis.location.search.substr(1));
+    currentParams[pageKey] = pageNumber;
+    const newParams = qs.stringify(currentParams, {
+      encoder: urlEncode
+    });
+    const newPath = `${location.pathname}?${newParams}`;
+    return newPath;
+  }
+  previousPagePath() {
+    const {
+      result
+    } = this.p;
+    let previousPage;
+    if (result.currentPage() > 1) {
+      previousPage = result.currentPage() - 1;
+    } else {
+      previousPage = result.currentPage();
+    }
+    return this.pagePath(previousPage);
+  }
+  nextPagePath() {
+    const {
+      result
+    } = this.p;
+    let nextPage;
+    if (result.currentPage() < this.tt.totalPages) {
+      nextPage = result.currentPage() + 1;
+    } else {
+      nextPage = result.currentPage();
+    }
+    return this.pagePath(nextPage);
+  }
+  showBackwardsDots = () => this.p.result.currentPage() - 5 > 1;
+  showForwardsDots = () => this.p.result.currentPage() + 5 < this.tt.totalPages;
+  render() {
+    const {
+      result
+    } = this.p;
+    const {
+      pages,
+      totalPages
+    } = this.tt;
+    const showNextPage = result.currentPage() < totalPages;
+    const showLastPage = result.currentPage() < totalPages;
+    const showPreviousPage = result.currentPage() > 1;
+    const showFirstPage = result.currentPage() > 1;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("ul", {
+      className: "pagination",
+      "data-pages-length": pages.length
+    }, /*#__PURE__*/React.createElement("li", {
+      className: `page-item ${!showPreviousPage ? "disabled" : ""}`,
+      key: "page-first"
+    }, !showPreviousPage && /*#__PURE__*/React.createElement(Text, null, "\u21E4"), showPreviousPage && /*#__PURE__*/React.createElement(Link, {
+      dataSet: {
+        class: "page-link"
+      },
+      to: this.pagePath(1)
+    }, /*#__PURE__*/React.createElement(Text, null, "\u21E4"))), /*#__PURE__*/React.createElement("li", {
+      className: `page-item ${!showFirstPage ? "disabled" : ""}`,
+      key: "page-previous"
+    }, !showFirstPage && /*#__PURE__*/React.createElement(Text, null, "\u2190"), showFirstPage && /*#__PURE__*/React.createElement(Link, {
+      dataSet: {
+        class: "page-link"
+      },
+      to: this.previousPagePath()
+    }, /*#__PURE__*/React.createElement(Text, null, "\u2190"))), this.showBackwardsDots() && /*#__PURE__*/React.createElement("li", {
+      className: "page-item disabled"
+    }, "\u2026"), pages.map(page => /*#__PURE__*/React.createElement("li", {
+      className: `page-item ${this.isPageActiveClass(page)}`,
+      "data-active": this.isPageActiveClass(page) == "active",
+      "data-page": page,
+      key: `page-${page}`
+    }, this.isPageActiveClass(page) == "active" && page, this.isPageActiveClass(page) == "not-active" && /*#__PURE__*/React.createElement(Link, {
+      dataSet: {
+        class: "page-link"
+      },
+      to: this.pagePath(page)
+    }, /*#__PURE__*/React.createElement(Text, null, page)))), this.showForwardsDots() && /*#__PURE__*/React.createElement("li", {
+      className: "page-item disabled"
+    }, "\u2026"), /*#__PURE__*/React.createElement("li", {
+      className: `page-item ${!showNextPage ? "disabled" : ""}`,
+      key: "page-next"
+    }, !showNextPage && /*#__PURE__*/React.createElement(Text, null, "\u2192"), showNextPage && /*#__PURE__*/React.createElement(Link, {
+      dataSet: {
+        class: "page-link"
+      },
+      to: this.nextPagePath()
+    }, /*#__PURE__*/React.createElement(Text, null, "\u2192"))), /*#__PURE__*/React.createElement("li", {
+      className: `page-item ${!showLastPage ? "disabled" : ""}`,
+      key: "page-last"
+    }, !showLastPage && /*#__PURE__*/React.createElement(Text, null, "\u21E5"), showLastPage && /*#__PURE__*/React.createElement(Link, {
+      dataSet: {
+        class: "page-link"
+      },
+      to: this.pagePath(totalPages)
+    }, /*#__PURE__*/React.createElement(Text, null, "\u21E5")))));
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","instanceOfClassName","Link","PropTypes","propTypesExact","memo","qs","React","useMemo","Text","Result","shapeComponent","urlEncode","ApiMakerBootstrapPaginate","propTypes","result","oneOfType","instanceOf","isRequired","setup","p","totalPages","Math","ceil","count","perPage","pages","calculatePages","currentPage","tt","pagesFrom","pagesTo","i","push","isPageActiveClass","pageNumber","pagePath","pageKey","data","collection","queryArgs","currentParams","parse","globalThis","location","search","substr","newParams","stringify","encoder","newPath","pathname","previousPagePath","previousPage","nextPagePath","nextPage","showBackwardsDots","showForwardsDots","render","showNextPage","showLastPage","showPreviousPage","showFirstPage","createElement","Fragment","className","length","key","dataSet","class","to","map","page"],"sources":["../../src/bootstrap/paginate.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport instanceOfClassName from \"../instance-of-class-name\"\nimport Link from \"../link\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport memo from \"set-state-compare/src/memo\"\nimport qs from \"qs\"\nimport React, {useMemo} from \"react\"\nimport Text from \"../utils/text\"\nimport Result from \"../result\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport urlEncode from \"../url-encode\"\n\nexport default memo(shapeComponent(class ApiMakerBootstrapPaginate extends BaseComponent {\n  static propTypes = propTypesExact({\n    result: PropTypes.oneOfType([\n      instanceOfClassName(\"ApiMakerResult\"),\n      PropTypes.instanceOf(Result)\n    ]).isRequired\n  })\n\n  setup() {\n    const {result} = this.p\n\n    this.totalPages = useMemo(\n      () => Math.ceil(result.count() / result.perPage()),\n      [result.count(), result.perPage()]\n    )\n    this.pages = useMemo(\n      () => this.calculatePages(),\n      [result.currentPage(), this.totalPages]\n    )\n  }\n\n  calculatePages () {\n    const {result} = this.p\n    const {totalPages} = this.tt\n    const currentPage = result.currentPage()\n    const pages = []\n\n    let pagesFrom = currentPage - 5\n    let pagesTo = currentPage + 5\n\n    if (pagesFrom < 1) {\n      pagesFrom = 1\n    }\n\n    if (pagesTo > totalPages) {\n      pagesTo = totalPages\n    }\n\n    for (let i = pagesFrom; i <= pagesTo; i++) {\n      pages.push(i)\n    }\n\n    return pages\n  }\n\n  isPageActiveClass = (pageNumber) => this.p.result.currentPage() == pageNumber ? \"active\" : \"not-active\"\n\n  pagePath (pageNumber) {\n    let pageKey = this.p.result.data.collection.queryArgs.pageKey\n\n    if (!pageKey) {\n      pageKey = \"page\"\n    }\n\n    const currentParams = qs.parse(globalThis.location.search.substr(1))\n    currentParams[pageKey] = pageNumber\n    const newParams = qs.stringify(currentParams, {encoder: urlEncode})\n    const newPath = `${location.pathname}?${newParams}`\n\n    return newPath\n  }\n\n  previousPagePath () {\n    const {result} = this.p\n    let previousPage\n\n    if (result.currentPage() > 1) {\n      previousPage = result.currentPage() - 1\n    } else {\n      previousPage = result.currentPage()\n    }\n\n    return this.pagePath(previousPage)\n  }\n\n  nextPagePath () {\n    const {result} = this.p\n    let nextPage\n\n    if (result.currentPage() < this.tt.totalPages) {\n      nextPage = result.currentPage() + 1\n    } else {\n      nextPage = result.currentPage()\n    }\n\n    return this.pagePath(nextPage)\n  }\n\n  showBackwardsDots = () => (this.p.result.currentPage() - 5 > 1)\n  showForwardsDots = () => (this.p.result.currentPage() + 5 < this.tt.totalPages)\n\n  render () {\n    const {result} = this.p\n    const {pages, totalPages} = this.tt\n    const showNextPage = result.currentPage() < totalPages\n    const showLastPage = result.currentPage() < totalPages\n    const showPreviousPage = result.currentPage() > 1\n    const showFirstPage = result.currentPage() > 1\n\n    return (\n      <>\n        <ul className=\"pagination\" data-pages-length={pages.length}>\n          <li className={`page-item ${!showPreviousPage ? \"disabled\" : \"\"}`} key=\"page-first\">\n            {!showPreviousPage &&\n              <Text>⇤</Text>\n            }\n            {showPreviousPage &&\n              <Link dataSet={{class: \"page-link\"}} to={this.pagePath(1)}>\n                <Text>⇤</Text>\n              </Link>\n            }\n          </li>\n          <li className={`page-item ${!showFirstPage ? \"disabled\" : \"\"}`} key=\"page-previous\">\n            {!showFirstPage &&\n              <Text>←</Text>\n            }\n            {showFirstPage &&\n              <Link dataSet={{class: \"page-link\"}} to={this.previousPagePath()}>\n                <Text>←</Text>\n              </Link>\n            }\n          </li>\n          {this.showBackwardsDots() &&\n            <li className=\"page-item disabled\">\n              &hellip;\n            </li>\n          }\n          {pages.map((page) =>\n            <li\n              className={`page-item ${this.isPageActiveClass(page)}`}\n              data-active={this.isPageActiveClass(page) == \"active\"}\n              data-page={page}\n              key={`page-${page}`}\n            >\n              {this.isPageActiveClass(page) == \"active\" &&\n                page\n              }\n              {this.isPageActiveClass(page) == \"not-active\" &&\n                <Link dataSet={{class: \"page-link\"}} to={this.pagePath(page)}>\n                  <Text>{page}</Text>\n                </Link>\n              }\n            </li>\n          )}\n          {this.showForwardsDots() &&\n            <li className=\"page-item disabled\">\n              &hellip;\n            </li>\n          }\n          <li className={`page-item ${!showNextPage ? \"disabled\" : \"\"}`} key=\"page-next\">\n            {!showNextPage &&\n              <Text>→</Text>\n            }\n            {showNextPage &&\n              <Link dataSet={{class: \"page-link\"}} to={this.nextPagePath()}>\n                <Text>→</Text>\n              </Link>\n            }\n          </li>\n          <li className={`page-item ${!showLastPage ? \"disabled\" : \"\"}`} key=\"page-last\">\n            {!showLastPage &&\n              <Text>⇥</Text>\n            }\n            {showLastPage &&\n              <Link dataSet={{class: \"page-link\"}} to={this.pagePath(totalPages)}>\n                <Text>⇥</Text>\n              </Link>\n            }\n          </li>\n        </ul>\n      </>\n    )\n  }\n}))\n"],"mappings":"AAAA,OAAOA,aAAa,MAAM,mBAAmB;AAC7C,OAAOC,mBAAmB,MAAM,2BAA2B;AAC3D,OAAOC,IAAI,MAAM,SAAS;AAC1B,OAAOC,SAAS,MAAM,YAAY;AAClC,OAAOC,cAAc,MAAM,kBAAkB;AAC7C,OAAOC,IAAI,MAAM,4BAA4B;AAC7C,OAAOC,EAAE,MAAM,IAAI;AACnB,OAAOC,KAAK,IAAGC,OAAO,QAAO,OAAO;AACpC,OAAOC,IAAI,MAAM,eAAe;AAChC,OAAOC,MAAM,MAAM,WAAW;AAC9B,SAAQC,cAAc,QAAO,uCAAuC;AACpE,OAAOC,SAAS,MAAM,eAAe;AAErC,eAAeP,IAAI,CAACM,cAAc,CAAC,MAAME,yBAAyB,SAASb,aAAa,CAAC;EACvF,OAAOc,SAAS,GAAGV,cAAc,CAAC;IAChCW,MAAM,EAAEZ,SAAS,CAACa,SAAS,CAAC,CAC1Bf,mBAAmB,CAAC,gBAAgB,CAAC,EACrCE,SAAS,CAACc,UAAU,CAACP,MAAM,CAAC,CAC7B,CAAC,CAACQ;EACL,CAAC,CAAC;EAEFC,KAAKA,CAAA,EAAG;IACN,MAAM;MAACJ;IAAM,CAAC,GAAG,IAAI,CAACK,CAAC;IAEvB,IAAI,CAACC,UAAU,GAAGb,OAAO,CACvB,MAAMc,IAAI,CAACC,IAAI,CAACR,MAAM,CAACS,KAAK,CAAC,CAAC,GAAGT,MAAM,CAACU,OAAO,CAAC,CAAC,CAAC,EAClD,CAACV,MAAM,CAACS,KAAK,CAAC,CAAC,EAAET,MAAM,CAACU,OAAO,CAAC,CAAC,CACnC,CAAC;IACD,IAAI,CAACC,KAAK,GAAGlB,OAAO,CAClB,MAAM,IAAI,CAACmB,cAAc,CAAC,CAAC,EAC3B,CAACZ,MAAM,CAACa,WAAW,CAAC,CAAC,EAAE,IAAI,CAACP,UAAU,CACxC,CAAC;EACH;EAEAM,cAAcA,CAAA,EAAI;IAChB,MAAM;MAACZ;IAAM,CAAC,GAAG,IAAI,CAACK,CAAC;IACvB,MAAM;MAACC;IAAU,CAAC,GAAG,IAAI,CAACQ,EAAE;IAC5B,MAAMD,WAAW,GAAGb,MAAM,CAACa,WAAW,CAAC,CAAC;IACxC,MAAMF,KAAK,GAAG,EAAE;IAEhB,IAAII,SAAS,GAAGF,WAAW,GAAG,CAAC;IAC/B,IAAIG,OAAO,GAAGH,WAAW,GAAG,CAAC;IAE7B,IAAIE,SAAS,GAAG,CAAC,EAAE;MACjBA,SAAS,GAAG,CAAC;IACf;IAEA,IAAIC,OAAO,GAAGV,UAAU,EAAE;MACxBU,OAAO,GAAGV,UAAU;IACtB;IAEA,KAAK,IAAIW,CAAC,GAAGF,SAAS,EAAEE,CAAC,IAAID,OAAO,EAAEC,CAAC,EAAE,EAAE;MACzCN,KAAK,CAACO,IAAI,CAACD,CAAC,CAAC;IACf;IAEA,OAAON,KAAK;EACd;EAEAQ,iBAAiB,GAAIC,UAAU,IAAK,IAAI,CAACf,CAAC,CAACL,MAAM,CAACa,WAAW,CAAC,CAAC,IAAIO,UAAU,GAAG,QAAQ,GAAG,YAAY;EAEvGC,QAAQA,CAAED,UAAU,EAAE;IACpB,IAAIE,OAAO,GAAG,IAAI,CAACjB,CAAC,CAACL,MAAM,CAACuB,IAAI,CAACC,UAAU,CAACC,SAAS,CAACH,OAAO;IAE7D,IAAI,CAACA,OAAO,EAAE;MACZA,OAAO,GAAG,MAAM;IAClB;IAEA,MAAMI,aAAa,GAAGnC,EAAE,CAACoC,KAAK,CAACC,UAAU,CAACC,QAAQ,CAACC,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,CAAC;IACpEL,aAAa,CAACJ,OAAO,CAAC,GAAGF,UAAU;IACnC,MAAMY,SAAS,GAAGzC,EAAE,CAAC0C,SAAS,CAACP,aAAa,EAAE;MAACQ,OAAO,EAAErC;IAAS,CAAC,CAAC;IACnE,MAAMsC,OAAO,GAAG,GAAGN,QAAQ,CAACO,QAAQ,IAAIJ,SAAS,EAAE;IAEnD,OAAOG,OAAO;EAChB;EAEAE,gBAAgBA,CAAA,EAAI;IAClB,MAAM;MAACrC;IAAM,CAAC,GAAG,IAAI,CAACK,CAAC;IACvB,IAAIiC,YAAY;IAEhB,IAAItC,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC,EAAE;MAC5ByB,YAAY,GAAGtC,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC;IACzC,CAAC,MAAM;MACLyB,YAAY,GAAGtC,MAAM,CAACa,WAAW,CAAC,CAAC;IACrC;IAEA,OAAO,IAAI,CAACQ,QAAQ,CAACiB,YAAY,CAAC;EACpC;EAEAC,YAAYA,CAAA,EAAI;IACd,MAAM;MAACvC;IAAM,CAAC,GAAG,IAAI,CAACK,CAAC;IACvB,IAAImC,QAAQ;IAEZ,IAAIxC,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,IAAI,CAACC,EAAE,CAACR,UAAU,EAAE;MAC7CkC,QAAQ,GAAGxC,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC;IACrC,CAAC,MAAM;MACL2B,QAAQ,GAAGxC,MAAM,CAACa,WAAW,CAAC,CAAC;IACjC;IAEA,OAAO,IAAI,CAACQ,QAAQ,CAACmB,QAAQ,CAAC;EAChC;EAEAC,iBAAiB,GAAGA,CAAA,KAAO,IAAI,CAACpC,CAAC,CAACL,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC,GAAG,CAAE;EAC/D6B,gBAAgB,GAAGA,CAAA,KAAO,IAAI,CAACrC,CAAC,CAACL,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAACC,EAAE,CAACR,UAAW;EAE/EqC,MAAMA,CAAA,EAAI;IACR,MAAM;MAAC3C;IAAM,CAAC,GAAG,IAAI,CAACK,CAAC;IACvB,MAAM;MAACM,KAAK;MAAEL;IAAU,CAAC,GAAG,IAAI,CAACQ,EAAE;IACnC,MAAM8B,YAAY,GAAG5C,MAAM,CAACa,WAAW,CAAC,CAAC,GAAGP,UAAU;IACtD,MAAMuC,YAAY,GAAG7C,MAAM,CAACa,WAAW,CAAC,CAAC,GAAGP,UAAU;IACtD,MAAMwC,gBAAgB,GAAG9C,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC;IACjD,MAAMkC,aAAa,GAAG/C,MAAM,CAACa,WAAW,CAAC,CAAC,GAAG,CAAC;IAE9C,oBACErB,KAAA,CAAAwD,aAAA,CAAAxD,KAAA,CAAAyD,QAAA,qBACEzD,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAC,YAAY;MAAC,qBAAmBvC,KAAK,CAACwC;IAAO,gBACzD3D,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAE,aAAa,CAACJ,gBAAgB,GAAG,UAAU,GAAG,EAAE,EAAG;MAACM,GAAG,EAAC;IAAY,GAChF,CAACN,gBAAgB,iBAChBtD,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CAAC,EAEfoD,gBAAgB,iBACftD,KAAA,CAAAwD,aAAA,CAAC7D,IAAI;MAACkE,OAAO,EAAE;QAACC,KAAK,EAAE;MAAW,CAAE;MAACC,EAAE,EAAE,IAAI,CAAClC,QAAQ,CAAC,CAAC;IAAE,gBACxD7B,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CACT,CAEN,CAAC,eACLF,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAE,aAAa,CAACH,aAAa,GAAG,UAAU,GAAG,EAAE,EAAG;MAACK,GAAG,EAAC;IAAe,GAChF,CAACL,aAAa,iBACbvD,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CAAC,EAEfqD,aAAa,iBACZvD,KAAA,CAAAwD,aAAA,CAAC7D,IAAI;MAACkE,OAAO,EAAE;QAACC,KAAK,EAAE;MAAW,CAAE;MAACC,EAAE,EAAE,IAAI,CAAClB,gBAAgB,CAAC;IAAE,gBAC/D7C,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CACT,CAEN,CAAC,EACJ,IAAI,CAAC+C,iBAAiB,CAAC,CAAC,iBACvBjD,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAC;IAAoB,GAAC,QAE/B,CAAC,EAENvC,KAAK,CAAC6C,GAAG,CAAEC,IAAI,iBACdjE,KAAA,CAAAwD,aAAA;MACEE,SAAS,EAAE,aAAa,IAAI,CAAC/B,iBAAiB,CAACsC,IAAI,CAAC,EAAG;MACvD,eAAa,IAAI,CAACtC,iBAAiB,CAACsC,IAAI,CAAC,IAAI,QAAS;MACtD,aAAWA,IAAK;MAChBL,GAAG,EAAE,QAAQK,IAAI;IAAG,GAEnB,IAAI,CAACtC,iBAAiB,CAACsC,IAAI,CAAC,IAAI,QAAQ,IACvCA,IAAI,EAEL,IAAI,CAACtC,iBAAiB,CAACsC,IAAI,CAAC,IAAI,YAAY,iBAC3CjE,KAAA,CAAAwD,aAAA,CAAC7D,IAAI;MAACkE,OAAO,EAAE;QAACC,KAAK,EAAE;MAAW,CAAE;MAACC,EAAE,EAAE,IAAI,CAAClC,QAAQ,CAACoC,IAAI;IAAE,gBAC3DjE,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAE+D,IAAW,CACd,CAEN,CACN,CAAC,EACA,IAAI,CAACf,gBAAgB,CAAC,CAAC,iBACtBlD,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAC;IAAoB,GAAC,QAE/B,CAAC,eAEP1D,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAE,aAAa,CAACN,YAAY,GAAG,UAAU,GAAG,EAAE,EAAG;MAACQ,GAAG,EAAC;IAAW,GAC3E,CAACR,YAAY,iBACZpD,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CAAC,EAEfkD,YAAY,iBACXpD,KAAA,CAAAwD,aAAA,CAAC7D,IAAI;MAACkE,OAAO,EAAE;QAACC,KAAK,EAAE;MAAW,CAAE;MAACC,EAAE,EAAE,IAAI,CAAChB,YAAY,CAAC;IAAE,gBAC3D/C,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CACT,CAEN,CAAC,eACLF,KAAA,CAAAwD,aAAA;MAAIE,SAAS,EAAE,aAAa,CAACL,YAAY,GAAG,UAAU,GAAG,EAAE,EAAG;MAACO,GAAG,EAAC;IAAW,GAC3E,CAACP,YAAY,iBACZrD,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CAAC,EAEfmD,YAAY,iBACXrD,KAAA,CAAAwD,aAAA,CAAC7D,IAAI;MAACkE,OAAO,EAAE;QAACC,KAAK,EAAE;MAAW,CAAE;MAACC,EAAE,EAAE,IAAI,CAAClC,QAAQ,CAACf,UAAU;IAAE,gBACjEd,KAAA,CAAAwD,aAAA,CAACtD,IAAI,QAAC,QAAO,CACT,CAEN,CACF,CACJ,CAAC;EAEP;AACF,CAAC,CAAC,CAAC","ignoreList":[]}