@kaspernj/api-maker 1.0.446 → 1.0.448

package/build/event-connection.js

@@ -0,0 +1,32 @@
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerEventConnection extends React.PureComponent {
+  static defaultProps = {
+    active: true
+  };
+  static propTypes = propTypesExact({
+    active: PropTypes.bool.isRequired,
+    model: PropTypes.object.isRequired,
+    event: PropTypes.string.isRequired,
+    onCall: PropTypes.func.isRequired
+  });
+  componentDidMount() {
+    this.subscription = ModelEvents.connect(this.props.model, this.props.event, (...args) => this.onCall(...args));
+  }
+  componentWillUnmount() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+    }
+  }
+  render() {
+    return null;
+  }
+  onCall(...args) {
+    if (this.props.active) {
+      this.props.onCall(...args);
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/event-model-class.js

@@ -0,0 +1,24 @@
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerEventModelClass extends React.PureComponent {
+  static propTypes = propTypesExact({
+    event: PropTypes.string.isRequired,
+    modelClass: PropTypes.func.isRequired,
+    onCall: PropTypes.func.isRequired
+  });
+  componentDidMount() {
+    this.connect();
+  }
+  componentWillUnmount() {
+    if (this.connection) {
+      this.connection.unsubscribe();
+    }
+  }
+  connect() {
+    this.connection = ModelEvents.connectModelClass(this.props.modelClass, this.props.event, this.props.onCall);
+  }
+  render = () => null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/events.js

@@ -0,0 +1,5 @@
+import EventEmitter from "events";
+const events = new EventEmitter();
+events.setMaxListeners(1000);
+export default events;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFdmVudEVtaXR0ZXIiLCJldmVudHMiLCJzZXRNYXhMaXN0ZW5lcnMiXSwic291cmNlcyI6WyIuLi9zcmMvZXZlbnRzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBFdmVudEVtaXR0ZXIgZnJvbSBcImV2ZW50c1wiXG5cbmNvbnN0IGV2ZW50cyA9IG5ldyBFdmVudEVtaXR0ZXIoKVxuXG5ldmVudHMuc2V0TWF4TGlzdGVuZXJzKDEwMDApXG5cbmV4cG9ydCBkZWZhdWx0IGV2ZW50c1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxZQUFZLE1BQU0sUUFBUTtBQUVqQyxNQUFNQyxNQUFNLEdBQUcsSUFBSUQsWUFBWSxDQUFDLENBQUM7QUFFakNDLE1BQU0sQ0FBQ0MsZUFBZSxDQUFDLElBQUksQ0FBQztBQUU1QixlQUFlRCxNQUFNIiwiaWdub3JlTGlzdCI6W119

package/build/form.js

@@ -0,0 +1,83 @@
+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 { createContext, useContext, useMemo } from "react";
+import BaseComponent from "./base-component";
+import FormDataObjectizer from "form-data-objectizer";
+import memo from "set-state-compare/src/memo";
+import { Platform } from "react-native";
+import PropTypes from "prop-types";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+const FormContext = /*#__PURE__*/createContext(null);
+class FormInputs {
+  constructor(props) {
+    this.inputs = {};
+    this.onSubmit = props?.onSubmit;
+  }
+  asObject() {
+    const result = {};
+    const formDataObjectizer = new FormDataObjectizer();
+    for (const key in this.inputs) {
+      const value = this.inputs[key];
+      formDataObjectizer.treatInitial(key, value, result);
+    }
+    return result;
+  }
+  setValue(name, value) {
+    if (!name) throw new Error("'name' is required");
+    this.inputs[name] = value;
+  }
+  setValueWithHidden(name, value) {
+    this.setValue(name, value);
+    if (Platform.OS == "web") {
+      return /*#__PURE__*/React.createElement("input", {
+        name: name,
+        type: "hidden",
+        value: value !== null && value !== undefined ? value : ""
+      });
+    }
+  }
+  submit() {
+    if (this.onSubmit) {
+      this.onSubmit();
+    }
+  }
+}
+const Form = memo(shapeComponent(class Form extends BaseComponent {
+  static propTypes = {
+    children: PropTypes.node,
+    formRef: PropTypes.object,
+    onSubmit: PropTypes.func,
+    setForm: PropTypes.func
+  };
+  render() {
+    const {
+      children,
+      formRef,
+      onSubmit,
+      setForm,
+      ...restProps
+    } = this.props;
+    const form = useMemo(() => new FormInputs({
+      onSubmit
+    }), []);
+    useMemo(() => {
+      if (setForm) {
+        setForm(form);
+      }
+    }, [setForm]);
+    return /*#__PURE__*/React.createElement(FormContext.Provider, {
+      value: form
+    }, Platform.OS == "web" && /*#__PURE__*/React.createElement("form", _extends({
+      ref: formRef,
+      onSubmit: this.tt.onFormSubmit
+    }, restProps), children), Platform.OS != "web" && this.props.children);
+  }
+  onFormSubmit = e => {
+    e.preventDefault();
+    if (this.props.onSubmit) {
+      this.props.onSubmit();
+    }
+  };
+}));
+const useForm = () => useContext(FormContext);
+export { Form, FormContext, FormInputs, useForm };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/index.js

@@ -0,0 +1,3 @@
+const stub = "Hello World";
+export { stub };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzdHViIl0sInNvdXJjZXMiOlsiLi4vc3JjL2luZGV4LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHN0dWIgPSBcIkhlbGxvIFdvcmxkXCJcblxuZXhwb3J0IHtzdHVifVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxNQUFNQSxJQUFJLEdBQUcsYUFBYTtBQUUxQixTQUFRQSxJQUFJIiwiaWdub3JlTGlzdCI6W119

package/build/inputs/attachment.js

@@ -0,0 +1,121 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import BaseComponent from "../base-component";
+import { Input as ApiMakerInput } from "@kaspernj/api-maker/build/inputs/input";
+import Checkbox from "./checkbox";
+import memo from "set-state-compare/src/memo";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+export default memo(shapeComponent(class ApiMakerInputsAttachment extends BaseComponent {
+  static propTypes = {
+    className: PropTypes.string,
+    model: PropTypes.object.isRequired,
+    onPurgeChanged: PropTypes.func,
+    purgeName: PropTypes.string
+  };
+  setup() {
+    const {
+      inputProps
+    } = useInput({
+      props: this.props
+    });
+    this.setInstance({
+      inputProps
+    });
+    this.useStates({
+      purgeChecked: false
+    });
+  }
+  render() {
+    const {
+      inputProps
+    } = this.tt;
+    const {
+      attribute,
+      checkboxComponent,
+      className,
+      label,
+      model,
+      name,
+      onPurgeChanged,
+      purgeName,
+      wrapperOpts,
+      ...restProps
+    } = this.props;
+    const CheckboxComponent = checkboxComponent || Checkbox;
+    const newInputProps = Object.assign({}, inputProps, {
+      type: "file"
+    });
+    return /*#__PURE__*/React.createElement("div", _extends({
+      className: classNames("api-maker--inputs--attachment", "components--inputs--input", className)
+    }, restProps), this.isImage() && /*#__PURE__*/React.createElement("a", {
+      href: this.getUrl(),
+      target: "_blank"
+    }, /*#__PURE__*/React.createElement("img", {
+      src: this.getUrl(),
+      style: {
+        maxWidth: "200px",
+        maxHeight: "200px"
+      }
+    })), this.getUrl() && /*#__PURE__*/React.createElement("div", {
+      className: "input-checkbox",
+      style: {
+        paddingTop: "15px",
+        paddingBottom: "15px"
+      }
+    }, /*#__PURE__*/React.createElement(CheckboxComponent, {
+      id: this.getPurgeInputId(),
+      name: this.getPurgeInputName(),
+      onChange: this.props.onPurgeChanged
+    }), /*#__PURE__*/React.createElement("label", {
+      className: "checkbox-label",
+      htmlFor: this.getPurgeInputId()
+    }, I18n.t("js.shared.delete"))), !this.s.purgeChecked && /*#__PURE__*/React.createElement(ApiMakerInput, {
+      defaultValue: null,
+      inputProps: newInputProps,
+      model: model
+    }));
+  }
+  getContentType() {
+    const {
+      attribute,
+      model
+    } = this.p;
+    const attributeName = `${attribute}ContentType`;
+    if (!(attributeName in model)) throw new Error(`No such method on ${model.modelClassData().name}: ${attributeName}`);
+    return model[attributeName]();
+  }
+  getPurgeInputId() {
+    const {
+      inputProps
+    } = this.tt;
+    return `${inputProps.id}_purge`;
+  }
+  getPurgeInputName() {
+    if ("purgeName" in this.props) return this.props.purgeName;
+    const {
+      inputProps
+    } = this.tt;
+    if (!inputProps.name) return null;
+    const match = inputProps.name.match(/^(.+)\[(.+?)\]$/);
+    const purgeInputName = `${match[1]}[${match[2]}_purge]`;
+    return purgeInputName;
+  }
+  getUrl() {
+    const {
+      attribute,
+      model
+    } = this.p;
+    const attributeName = `${attribute}Url`;
+    if (!(attributeName in model)) throw new Error(`No such method on ${model.modelClassData().name}: ${attributeName}`);
+    return model[attributeName]();
+  }
+  isImage() {
+    return this.getContentType()?.startsWith("image/");
+  }
+  onPurgeChanged = e => {
+    this.setState({
+      purgeChecked: digg(e, "target", "checked")
+    });
+    if (this.props.onPurgeChanged) this.props.onPurgeChanged(e);
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","Input","ApiMakerInput","Checkbox","memo","shapeComponent","ApiMakerInputsAttachment","propTypes","className","PropTypes","string","model","object","isRequired","onPurgeChanged","func","purgeName","setup","inputProps","useInput","props","setInstance","useStates","purgeChecked","render","tt","attribute","checkboxComponent","label","name","wrapperOpts","restProps","CheckboxComponent","newInputProps","Object","assign","type","React","createElement","_extends","classNames","isImage","href","getUrl","target","src","style","maxWidth","maxHeight","paddingTop","paddingBottom","id","getPurgeInputId","getPurgeInputName","onChange","htmlFor","I18n","t","s","defaultValue","getContentType","p","attributeName","Error","modelClassData","match","purgeInputName","startsWith","e","setState","digg"],"sources":["../../src/inputs/attachment.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport {Input as ApiMakerInput} from \"@kaspernj/api-maker/build/inputs/input\"\nimport Checkbox from \"./checkbox\"\nimport memo from \"set-state-compare/src/memo\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\n\nexport default memo(shapeComponent(class ApiMakerInputsAttachment extends BaseComponent {\n  static propTypes = {\n    className: PropTypes.string,\n    model: PropTypes.object.isRequired,\n    onPurgeChanged: PropTypes.func,\n    purgeName: PropTypes.string\n  }\n\n  setup() {\n    const {inputProps} = useInput({props: this.props})\n\n    this.setInstance({inputProps})\n    this.useStates({\n      purgeChecked: false\n    })\n  }\n\n  render() {\n    const {inputProps} = this.tt\n    const {attribute, checkboxComponent, className, label, model, name, onPurgeChanged, purgeName, wrapperOpts, ...restProps} = this.props\n    const CheckboxComponent = checkboxComponent || Checkbox\n    const newInputProps = Object.assign({}, inputProps, {type: \"file\"})\n\n    return (\n      <div className={classNames(\"api-maker--inputs--attachment\", \"components--inputs--input\", className)} {...restProps}>\n        {this.isImage() &&\n          <a href={this.getUrl()} target=\"_blank\">\n            <img src={this.getUrl()} style={{maxWidth: \"200px\", maxHeight: \"200px\"}} />\n          </a>\n        }\n        {this.getUrl() &&\n          <div className=\"input-checkbox\" style={{paddingTop: \"15px\", paddingBottom: \"15px\"}}>\n            <CheckboxComponent id={this.getPurgeInputId()} name={this.getPurgeInputName()} onChange={this.props.onPurgeChanged} />\n            <label className=\"checkbox-label\" htmlFor={this.getPurgeInputId()}>\n              {I18n.t(\"js.shared.delete\")}\n            </label>\n          </div>\n        }\n        {!this.s.purgeChecked &&\n          <ApiMakerInput\n            defaultValue={null}\n            inputProps={newInputProps}\n            model={model}\n          />\n        }\n      </div>\n    )\n  }\n\n  getContentType() {\n    const {attribute, model} = this.p\n    const attributeName = `${attribute}ContentType`\n\n    if (!(attributeName in model)) throw new Error(`No such method on ${model.modelClassData().name}: ${attributeName}`)\n\n    return model[attributeName]()\n  }\n\n  getPurgeInputId() {\n    const {inputProps} = this.tt\n\n    return `${inputProps.id}_purge`\n  }\n\n  getPurgeInputName() {\n    if (\"purgeName\" in this.props) return this.props.purgeName\n\n    const {inputProps} = this.tt\n\n    if (!inputProps.name) return null\n\n    const match = inputProps.name.match(/^(.+)\\[(.+?)\\]$/)\n    const purgeInputName = `${match[1]}[${match[2]}_purge]`\n\n    return purgeInputName\n  }\n\n  getUrl() {\n    const {attribute, model} = this.p\n    const attributeName = `${attribute}Url`\n\n    if (!(attributeName in model)) throw new Error(`No such method on ${model.modelClassData().name}: ${attributeName}`)\n\n    return model[attributeName]()\n  }\n\n  isImage() {\n    return this.getContentType()?.startsWith(\"image/\")\n  }\n\n  onPurgeChanged = (e) => {\n    this.setState({purgeChecked: digg(e, \"target\", \"checked\")})\n\n    if (this.props.onPurgeChanged) this.props.onPurgeChanged(e)\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/inputs/auto-submit.js

@@ -0,0 +1,36 @@
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+export default class ApiMakerInputsAutoSubmit {
+  constructor({
+    component
+  }) {
+    this.component = component;
+  }
+  autoSubmit() {
+    const {
+      attribute,
+      model
+    } = this.component.props;
+    const updateAttributeName = inflection.underscore(attribute);
+    const updateParams = {};
+    updateParams[updateAttributeName] = this.value();
+    model.update(updateParams);
+  }
+  value() {
+    const inputRef = this.component.props.inputRef || this.component.props.inputProps?.ref || this.component.inputProps?.ref || this.component.inputRef;
+    const input = digg(inputRef, "current");
+    if (input.type == "checkbox") {
+      if (input.checked) {
+        if (input.value !== undefined) {
+          return input.value;
+        } else {
+          return 1;
+        }
+      } else {
+        return 0;
+      }
+    }
+    return digg(input, "value");
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/inputs/checkbox.js

@@ -0,0 +1,145 @@
+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 AutoSubmit from "./auto-submit";
+import BaseComponent from "../base-component";
+import { digg } from "diggerize";
+import PropTypes from "prop-types";
+import memo from "set-state-compare/src/memo";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import useInput from "../use-input";
+import { useForm } from "../form";
+import { useMemo } from "react";
+import useUpdatedEvent from "../use-updated-event";
+export default memo(shapeComponent(class ApiMakerInputsCheckbox extends BaseComponent {
+  static defaultProps = {
+    autoRefresh: false,
+    autoSubmit: false,
+    defaultValue: 1,
+    model: null,
+    zeroInput: true
+  };
+  static propTypes = {
+    attribute: PropTypes.string,
+    autoRefresh: PropTypes.bool.isRequired,
+    autoSubmit: PropTypes.bool.isRequired,
+    defaultChecked: PropTypes.bool,
+    defaultValue: PropTypes.node,
+    id: PropTypes.string,
+    inputRef: PropTypes.object,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    onErrors: PropTypes.func,
+    onMatchValidationError: PropTypes.func,
+    zeroInput: PropTypes.bool
+  };
+  setup() {
+    const {
+      autoRefresh,
+      model
+    } = this.p;
+    const {
+      inputProps,
+      restProps: useInputRestProps
+    } = useInput({
+      props: this.props,
+      wrapperOptions: {
+        type: "checkbox"
+      }
+    });
+    const {
+      defaultValue,
+      name
+    } = inputProps;
+    this.setInstance({
+      form: useForm(),
+      inputProps,
+      useInputRestProps
+    });
+    useMemo(() => {
+      if (name) {
+        this.tt.form?.setValue(name, defaultValue);
+      }
+    }, []);
+    useUpdatedEvent(model, this.tt.onModelUpdated, {
+      active: Boolean(autoRefresh && model)
+    });
+  }
+  render() {
+    const {
+      inputProps,
+      useInputRestProps
+    } = this.tt;
+    const {
+      attribute,
+      autoRefresh,
+      autoSubmit,
+      checked,
+      defaultChecked,
+      defaultValue,
+      id,
+      inputRef,
+      model,
+      name,
+      onChange,
+      zeroInput,
+      ...restProps
+    } = useInputRestProps;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, zeroInput && inputProps.name && /*#__PURE__*/React.createElement("input", {
+      defaultValue: "0",
+      name: inputProps.name,
+      type: "hidden"
+    }), /*#__PURE__*/React.createElement("input", _extends({}, inputProps, {
+      "data-auto-refresh": autoRefresh,
+      "data-auto-submit": autoSubmit,
+      defaultValue: defaultValue,
+      onChange: this.tt.onChanged,
+      type: "checkbox"
+    }, restProps)));
+  }
+  onChanged = (...args) => {
+    const {
+      form,
+      inputProps
+    } = this.tt;
+    const {
+      attribute,
+      autoSubmit,
+      model,
+      onChange
+    } = this.props;
+    const {
+      name
+    } = inputProps;
+    if (attribute && autoSubmit && model) new AutoSubmit({
+      component: this
+    }).autoSubmit();
+    console.log("onChanged", {
+      form,
+      name
+    });
+    if (form && name) {
+      const checked = args[0].target.checked;
+      console.log("Checkbox onChanged", {
+        checked
+      });
+      form.setValue(name, checked);
+    }
+    if (onChange) onChange(...args);
+  };
+  onModelUpdated = args => {
+    const inputRef = digg(this.tt.inputProps, "ref");
+    if (!inputRef.current) {
+      // This can happen if the component is being unmounted
+      return;
+    }
+    const {
+      attribute
+    } = this.p;
+    const newModel = digg(args, "model");
+    const currentChecked = digg(inputRef, "current", "checked");
+    const newValue = newModel.readAttribute(attribute);
+    if (currentChecked != newValue) {
+      inputRef.current.checked = newValue;
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["AutoSubmit","BaseComponent","digg","PropTypes","memo","shapeComponent","useInput","useForm","useMemo","useUpdatedEvent","ApiMakerInputsCheckbox","defaultProps","autoRefresh","autoSubmit","defaultValue","model","zeroInput","propTypes","attribute","string","bool","isRequired","defaultChecked","node","id","inputRef","object","name","onErrors","func","onMatchValidationError","setup","p","inputProps","restProps","useInputRestProps","props","wrapperOptions","type","setInstance","form","tt","setValue","onModelUpdated","active","Boolean","render","checked","onChange","React","createElement","Fragment","_extends","onChanged","args","component","console","log","target","current","newModel","currentChecked","newValue","readAttribute"],"sources":["../../src/inputs/checkbox.jsx"],"sourcesContent":["import AutoSubmit from \"./auto-submit\"\nimport BaseComponent from \"../base-component\"\nimport {digg} from \"diggerize\"\nimport PropTypes from \"prop-types\"\nimport memo from \"set-state-compare/src/memo\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport useInput from \"../use-input\"\nimport {useForm} from \"../form\"\nimport {useMemo} from \"react\"\nimport useUpdatedEvent from \"../use-updated-event\"\n\nexport default memo(shapeComponent(class ApiMakerInputsCheckbox extends BaseComponent {\n  static defaultProps = {\n    autoRefresh: false,\n    autoSubmit: false,\n    defaultValue: 1,\n    model: null,\n    zeroInput: true\n  }\n\n  static propTypes = {\n    attribute: PropTypes.string,\n    autoRefresh: PropTypes.bool.isRequired,\n    autoSubmit: PropTypes.bool.isRequired,\n    defaultChecked: PropTypes.bool,\n    defaultValue: PropTypes.node,\n    id: PropTypes.string,\n    inputRef: PropTypes.object,\n    model: PropTypes.object,\n    name: PropTypes.string,\n    onErrors: PropTypes.func,\n    onMatchValidationError: PropTypes.func,\n    zeroInput: PropTypes.bool\n  }\n\n  setup() {\n    const {autoRefresh, model} = this.p\n    const {inputProps, restProps: useInputRestProps} = useInput({props: this.props, wrapperOptions: {type: \"checkbox\"}})\n    const {defaultValue, name} = inputProps\n\n    this.setInstance({\n      form: useForm(),\n      inputProps,\n      useInputRestProps\n    })\n\n    useMemo(() => {\n      if (name) {\n        this.tt.form?.setValue(name, defaultValue)\n      }\n    }, [])\n\n    useUpdatedEvent(model, this.tt.onModelUpdated, {active: Boolean(autoRefresh && model)})\n  }\n\n  render () {\n    const {inputProps, useInputRestProps} = this.tt\n    const {\n      attribute,\n      autoRefresh,\n      autoSubmit,\n      checked,\n      defaultChecked,\n      defaultValue,\n      id,\n      inputRef,\n      model,\n      name,\n      onChange,\n      zeroInput,\n      ...restProps\n    } = useInputRestProps\n\n    return (\n      <>\n        {zeroInput && inputProps.name &&\n          <input defaultValue=\"0\" name={inputProps.name} type=\"hidden\" />\n        }\n        <input\n          {...inputProps}\n          data-auto-refresh={autoRefresh}\n          data-auto-submit={autoSubmit}\n          defaultValue={defaultValue}\n          onChange={this.tt.onChanged}\n          type=\"checkbox\"\n          {...restProps}\n        />\n      </>\n    )\n  }\n\n  onChanged = (...args) => {\n    const {form, inputProps} = this.tt\n    const {attribute, autoSubmit, model, onChange} = this.props\n    const {name} = inputProps\n\n    if (attribute && autoSubmit && model) new AutoSubmit({component: this}).autoSubmit()\n\n    console.log(\"onChanged\", {form, name})\n\n    if (form && name) {\n      const checked = args[0].target.checked\n\n      console.log(\"Checkbox onChanged\", {checked})\n\n      form.setValue(name, checked)\n    }\n\n    if (onChange) onChange(...args)\n  }\n\n  onModelUpdated = (args) => {\n    const inputRef = digg(this.tt.inputProps, \"ref\")\n\n    if (!inputRef.current) {\n      // This can happen if the component is being unmounted\n      return\n    }\n\n    const {attribute} = this.p\n    const newModel = digg(args, \"model\")\n    const currentChecked = digg(inputRef, \"current\", \"checked\")\n    const newValue = newModel.readAttribute(attribute)\n\n    if (currentChecked != newValue) {\n      inputRef.current.checked = newValue\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/inputs/checkboxes.js

@@ -0,0 +1,111 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import BaseComponent from "../base-component";
+import classNames from "classnames";
+import { digs } from "diggerize";
+import inputWrapper from "./input-wrapper";
+import * as inflection from "inflection";
+import InvalidFeedback from "../bootstrap/invalid-feedback";
+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";
+const ApiMakerInputsCheckboxes = memo(shapeComponent(class ApiMakerInputsCheckboxes extends BaseComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.string,
+    defaultValue: PropTypes.array,
+    id: PropTypes.string,
+    inputProps: PropTypes.object.isRequired,
+    label: PropTypes.node,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    onChange: PropTypes.func,
+    options: PropTypes.array.isRequired,
+    wrapperOpts: PropTypes.object
+  });
+  render() {
+    const {
+      className,
+      inputProps,
+      label,
+      wrapperOpts,
+      ...restProps
+    } = this.props;
+    return /*#__PURE__*/React.createElement("div", _extends({
+      className: classNames("component-bootstrap-check-boxes", className)
+    }, restProps), /*#__PURE__*/React.createElement("input", {
+      name: this.inputName(),
+      ref: this.props.inputProps.ref,
+      type: "hidden",
+      value: ""
+    }), this.props.options.map((option, index) => this.optionElement(option, index)));
+  }
+  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.props.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;
+    }
+  }
+  generatedId() {
+    if (!this.generatedIdValue) this.generatedIdValue = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    return this.generatedIdValue;
+  }
+  optionElement(option, index) {
+    const {
+      onChange,
+      options,
+      wrapperOpts
+    } = this.props;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    const id = `${this.generatedId()}-${index}`;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "checkboxes-option",
+      key: `option-${option[1]}`
+    }, /*#__PURE__*/React.createElement("input", {
+      className: this.inputCheckboxClassName(),
+      "data-option-value": option[1],
+      defaultChecked: this.isDefaultSelected(option[1]),
+      id: id,
+      name: this.inputName(),
+      onChange: onChange,
+      type: "checkbox",
+      value: option[1]
+    }), /*#__PURE__*/React.createElement("label", {
+      className: "ml-1",
+      htmlFor: id
+    }, option[0]), index + 1 == options.length && errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    }));
+  }
+}));
+export default inputWrapper(ApiMakerInputsCheckboxes);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","classNames","digs","inputWrapper","inflection","InvalidFeedback","PropTypes","propTypesExact","memo","shapeComponent","ApiMakerInputsCheckboxes","propTypes","attribute","string","defaultValue","array","id","inputProps","object","isRequired","label","node","model","name","onChange","func","options","wrapperOpts","render","className","restProps","props","React","createElement","_extends","inputName","ref","type","value","map","option","index","optionElement","inputDefaultValue","inputCheckboxClassName","errors","length","push","join","modelClassData","paramKey","underscore","isDefaultSelected","constructor","Array","includes","generatedId","generatedIdValue","Math","random","toString","substring","key","defaultChecked","htmlFor"],"sources":["../../src/inputs/checkboxes.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport {digs} from \"diggerize\"\nimport inputWrapper from \"./input-wrapper\"\nimport * as inflection from \"inflection\"\nimport InvalidFeedback from \"../bootstrap/invalid-feedback\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport memo from \"set-state-compare/src/memo\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\n\nconst ApiMakerInputsCheckboxes = memo(shapeComponent(class ApiMakerInputsCheckboxes extends BaseComponent {\n  static propTypes = propTypesExact({\n    attribute: PropTypes.string,\n    defaultValue: PropTypes.array,\n    id: PropTypes.string,\n    inputProps: PropTypes.object.isRequired,\n    label: PropTypes.node,\n    model: PropTypes.object,\n    name: PropTypes.string,\n    onChange: PropTypes.func,\n    options: PropTypes.array.isRequired,\n    wrapperOpts: PropTypes.object\n  })\n\n  render () {\n    const {className, inputProps, label, wrapperOpts, ...restProps} = this.props\n\n    return (\n      <div className={classNames(\"component-bootstrap-check-boxes\", className)} {...restProps}>\n        <input name={this.inputName()} ref={this.props.inputProps.ref} type=\"hidden\" value=\"\" />\n        {this.props.options.map((option, index) => this.optionElement(option, index))}\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])\n        throw `No such attribute: ${attribute}`\n\n      return this.props.model[attribute]()\n    }\n  }\n\n  inputCheckboxClassName () {\n    const classNames = []\n\n    if (this.props.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  generatedId () {\n    if (!this.generatedIdValue)\n      this.generatedIdValue = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15)\n\n    return this.generatedIdValue\n  }\n\n  optionElement (option, index) {\n    const {onChange, options, wrapperOpts} = this.props\n    const {errors} = digs(wrapperOpts, \"errors\")\n    const id = `${this.generatedId()}-${index}`\n\n    return (\n      <div className=\"checkboxes-option\" key={`option-${option[1]}`}>\n        <input\n          className={this.inputCheckboxClassName()}\n          data-option-value={option[1]}\n          defaultChecked={this.isDefaultSelected(option[1])}\n          id={id}\n          name={this.inputName()}\n          onChange={onChange}\n          type=\"checkbox\"\n          value={option[1]}\n        />\n\n        <label className=\"ml-1\" htmlFor={id}>\n          {option[0]}\n        </label>\n\n        {(index + 1) == options.length && errors.length > 0 &&\n          <InvalidFeedback errors={errors} />\n        }\n      </div>\n    )\n  }\n}))\n\nexport default inputWrapper(ApiMakerInputsCheckboxes)\n"],"mappings":"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","ignoreList":[]}