@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/bootstrap/attribute-row.js

@@ -0,0 +1,135 @@
+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 React, { useMemo } from "react";
+import classNames from "classnames";
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import memo from "set-state-compare/src/memo";
+import MoneyFormatter from "../money-formatter";
+import PropTypes from "prop-types";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import strftime from "strftime";
+import Text from "../utils/text";
+import useI18n from "i18n-on-steroids/src/use-i18n";
+import { View } from "react-native";
+export default memo(shapeComponent(class ApiMakerBootstrapAttributeRow extends ShapeComponent {
+  static defaultProps = {
+    checkIfAttributeLoaded: false
+  };
+  static propTypes = {
+    attribute: PropTypes.string,
+    checkIfAttributeLoaded: PropTypes.bool.isRequired,
+    children: PropTypes.node,
+    identifier: PropTypes.string,
+    label: PropTypes.oneOfType([PropTypes.node, PropTypes.string]),
+    model: PropTypes.object,
+    value: PropTypes.node
+  };
+  setup() {
+    const {
+      l,
+      t
+    } = useI18n({
+      namespace: "js.api_maker.attribute_row"
+    });
+    this.l = l;
+    this.t = t;
+    this.attribute = useMemo(() => {
+      if (this.props.attribute) {
+        return this.props.model?.constructor?.attributes()?.find(attribute => attribute.name() == inflection.underscore(this.props.attribute));
+      }
+    }, [this.props.attribute, this.props.model]);
+  }
+  render() {
+    const {
+      attribute,
+      checkIfAttributeLoaded,
+      children,
+      className,
+      identifier,
+      label,
+      model,
+      style,
+      value,
+      ...restProps
+    } = this.props;
+    const actualStyle = Object.assign({
+      paddingVertical: 8
+    }, style);
+    return /*#__PURE__*/React.createElement(View, _extends({
+      dataSet: {
+        attribute,
+        class: className,
+        component: "api-maker/attribute-row",
+        identifier
+      },
+      style: actualStyle
+    }, restProps), /*#__PURE__*/React.createElement(Text, {
+      dataSet: {
+        class: "attribute-row-label"
+      },
+      style: {
+        fontWeight: "bold"
+      }
+    }, this.label()), /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        class: "attribute-row-value"
+      },
+      style: {
+        marginTop: 3
+      }
+    }, this.value()));
+  }
+  label() {
+    const {
+      attribute,
+      label,
+      model
+    } = this.props;
+    if ("label" in this.props) return label;
+    if (attribute && model) return model.constructor.humanAttributeName(attribute);
+    throw new Error("Couldn't figure out label");
+  }
+  value() {
+    const {
+      attribute,
+      checkIfAttributeLoaded,
+      children,
+      model
+    } = this.props;
+    if (children) return children;
+    if (attribute && !(attribute in model)) throw new Error(`Attribute not found: ${digg(model.modelClassData(), "name")}#${attribute}`);
+    if (attribute && checkIfAttributeLoaded && !model.isAttributeLoaded(attribute)) return null;
+    if (attribute && model) {
+      const value = model[attribute]();
+      return this.valueContent(value);
+    }
+  }
+  valueContent(value) {
+    const {
+      l,
+      t
+    } = this.tt;
+    const columnType = this.attribute?.getColumn()?.getType();
+    if (columnType == "date") {
+      return /*#__PURE__*/React.createElement(Text, null, l("date.formats.default", value));
+    } else if (value instanceof Date) {
+      return /*#__PURE__*/React.createElement(Text, null, strftime("%Y-%m-%d %H:%M", value));
+    } else if (typeof value === "boolean") {
+      if (value) {
+        return /*#__PURE__*/React.createElement(Text, null, t("js.shared.yes", {
+          defaultValue: "Yes"
+        }));
+      }
+      return /*#__PURE__*/React.createElement(Text, null, t("js.shared.no", {
+        defaultValue: "No"
+      }));
+    } else if (MoneyFormatter.isMoney(value)) {
+      return /*#__PURE__*/React.createElement(Text, null, MoneyFormatter.format(value));
+    } else if (typeof value == "string") {
+      return /*#__PURE__*/React.createElement(Text, null, value);
+    } else {
+      return value;
+    }
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","classNames","digg","inflection","memo","MoneyFormatter","PropTypes","shapeComponent","ShapeComponent","strftime","Text","useI18n","View","ApiMakerBootstrapAttributeRow","defaultProps","checkIfAttributeLoaded","propTypes","attribute","string","bool","isRequired","children","node","identifier","label","oneOfType","model","object","value","setup","l","t","namespace","props","constructor","attributes","find","name","underscore","render","className","style","restProps","actualStyle","Object","assign","paddingVertical","createElement","_extends","dataSet","class","component","fontWeight","marginTop","humanAttributeName","Error","modelClassData","isAttributeLoaded","valueContent","tt","columnType","getColumn","getType","Date","defaultValue","isMoney","format"],"sources":["../../src/bootstrap/attribute-row.jsx"],"sourcesContent":["import React, {useMemo} from \"react\"\nimport classNames from \"classnames\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport memo from \"set-state-compare/src/memo\"\nimport MoneyFormatter from \"../money-formatter\"\nimport PropTypes from \"prop-types\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport strftime from \"strftime\"\nimport Text from \"../utils/text\"\nimport useI18n from \"i18n-on-steroids/src/use-i18n\"\nimport {View} from \"react-native\"\n\nexport default memo(shapeComponent(class ApiMakerBootstrapAttributeRow extends ShapeComponent {\n  static defaultProps = {\n    checkIfAttributeLoaded: false\n  }\n\n  static propTypes = {\n    attribute: PropTypes.string,\n    checkIfAttributeLoaded: PropTypes.bool.isRequired,\n    children: PropTypes.node,\n    identifier: PropTypes.string,\n    label: PropTypes.oneOfType([PropTypes.node, PropTypes.string]),\n    model: PropTypes.object,\n    value: PropTypes.node\n  }\n\n  setup() {\n    const {l, t} = useI18n({namespace: \"js.api_maker.attribute_row\"})\n\n    this.l = l\n    this.t = t\n    this.attribute = useMemo(\n      () => {\n        if (this.props.attribute) {\n          return this.props.model?.constructor?.attributes()?.find((attribute) => attribute.name() == inflection.underscore(this.props.attribute))\n        }\n      },\n      [this.props.attribute, this.props.model]\n    )\n  }\n\n  render () {\n    const {attribute, checkIfAttributeLoaded, children, className, identifier, label, model, style, value, ...restProps} = this.props\n    const actualStyle = Object.assign(\n      {\n        paddingVertical: 8\n      },\n      style\n    )\n\n    return (\n      <View\n        dataSet={{\n          attribute,\n          class: className,\n          component: \"api-maker/attribute-row\",\n          identifier\n        }}\n        style={actualStyle}\n        {...restProps}\n      >\n        <Text dataSet={{class: \"attribute-row-label\"}} style={{fontWeight: \"bold\"}}>\n          {this.label()}\n        </Text>\n        <View dataSet={{class: \"attribute-row-value\"}} style={{marginTop: 3}}>\n          {this.value()}\n        </View>\n      </View>\n    )\n  }\n\n  label() {\n    const {attribute, label, model} = this.props\n\n    if (\"label\" in this.props) return label\n    if (attribute && model) return model.constructor.humanAttributeName(attribute)\n\n    throw new Error(\"Couldn't figure out label\")\n  }\n\n  value() {\n    const {attribute, checkIfAttributeLoaded, children, model} = this.props\n\n    if (children) return children\n\n    if (attribute && !(attribute in model))\n      throw new Error(`Attribute not found: ${digg(model.modelClassData(), \"name\")}#${attribute}`)\n\n    if (attribute && checkIfAttributeLoaded && !model.isAttributeLoaded(attribute))\n      return null\n\n    if (attribute && model) {\n      const value = model[attribute]()\n\n      return this.valueContent(value)\n    }\n  }\n\n  valueContent(value) {\n    const {l, t} = this.tt\n    const columnType = this.attribute?.getColumn()?.getType()\n\n    if (columnType == \"date\") {\n      return (\n        <Text>{l(\"date.formats.default\", value)}</Text>\n      )\n    } else if (value instanceof Date) {\n      return (\n        <Text>{strftime(\"%Y-%m-%d %H:%M\", value)}</Text>\n      )\n    } else if (typeof value === \"boolean\") {\n      if (value) {\n        return (\n          <Text>{t(\"js.shared.yes\", {defaultValue: \"Yes\"})}</Text>\n        )\n      }\n\n      return (\n        <Text>{t(\"js.shared.no\", {defaultValue: \"No\"})}</Text>\n      )\n    } else if (MoneyFormatter.isMoney(value)) {\n      return (\n        <Text>{MoneyFormatter.format(value)}</Text>\n      )\n    } else if (typeof value == \"string\") {\n      return (\n        <Text>{value}</Text>\n      )\n    } else {\n      return value\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/bootstrap/attribute-rows.js

@@ -0,0 +1,31 @@
+import AttributeRow from "./attribute-row";
+import BaseComponent from "../base-component";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+export default memo(shapeComponent(class ApiMakerBootstrapAttributeRows extends BaseComponent {
+  static defaultProps = {
+    checkIfAttributeLoaded: false
+  };
+  static propTypes = propTypesExact({
+    attributes: PropTypes.array.isRequired,
+    checkIfAttributeLoaded: PropTypes.bool.isRequired,
+    model: PropTypes.object.isRequired
+  });
+  render() {
+    const {
+      attributes,
+      checkIfAttributeLoaded,
+      model
+    } = this.p;
+    return attributes.map(attribute => /*#__PURE__*/React.createElement(AttributeRow, {
+      attribute: attribute,
+      checkIfAttributeLoaded: checkIfAttributeLoaded,
+      key: `attribute-${attribute}`,
+      model: model
+    }));
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/bootstrap/card.js

@@ -0,0 +1,138 @@
+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 { digg, digs } from "diggerize";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import React, { useRef } from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+export default memo(shapeComponent(class ApiMakerBootstrapCard extends BaseComponent {
+  static defaultProps = {
+    defaultExpanded: true,
+    expandable: false,
+    expandableHide: false,
+    responsiveTable: true,
+    table: false
+  };
+  static propTypes = {
+    cardRef: PropTypes.object,
+    className: PropTypes.string,
+    children: PropTypes.node,
+    controls: PropTypes.node,
+    defaultExpanded: PropTypes.bool.isRequired,
+    expandable: PropTypes.bool.isRequired,
+    expandableHide: PropTypes.bool.isRequired,
+    footer: PropTypes.node,
+    header: PropTypes.node,
+    striped: PropTypes.bool,
+    responsiveTable: PropTypes.bool.isRequired,
+    table: PropTypes.bool.isRequired
+  };
+  setup() {
+    this.cardRef = useRef();
+    this.useStates({
+      expanded: this.props.defaultExpanded
+    });
+  }
+  render() {
+    const {
+      cardRef,
+      children,
+      className,
+      controls,
+      defaultExpanded,
+      expandable,
+      expandableHide,
+      footer,
+      header,
+      responsiveTable,
+      striped,
+      table,
+      ...restProps
+    } = this.props;
+    const {
+      expanded
+    } = digs(this.state, "expanded");
+    const cardHeaderStyle = {
+      display: "flex"
+    };
+    const cardRefToUse = cardRef || this.cardRef;
+    if (!expanded) cardHeaderStyle["borderBottom"] = "0";
+    return /*#__PURE__*/React.createElement("div", _extends({
+      className: classNames("component-bootstrap-card", "card", "card-default", className),
+      "data-has-footer": Boolean(footer),
+      ref: cardRefToUse
+    }, restProps), (controls || expandable || header) && /*#__PURE__*/React.createElement("div", {
+      className: "card-header",
+      style: cardHeaderStyle
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "card-header-label",
+      style: {
+        alignSelf: "center",
+        marginRight: "auto"
+      }
+    }, header), (controls || expandable) && /*#__PURE__*/React.createElement("div", {
+      className: "card-header-actions",
+      style: {
+        alignSelf: "center"
+      }
+    }, controls, expandable && expanded && /*#__PURE__*/React.createElement("a", {
+      className: "collapse-card-button text-muted",
+      href: "#",
+      onClick: digg(this, "onCollapseClicked")
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "fa fa-angle-up"
+    })), expandable && !expanded && /*#__PURE__*/React.createElement("a", {
+      className: "expand-card-button text-muted",
+      href: "#",
+      onClick: digg(this, "onExpandClicked")
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "fa fa-angle-down"
+    })))), (expanded || expandableHide) && /*#__PURE__*/React.createElement("div", {
+      className: this.bodyClassNames()
+    }, table && /*#__PURE__*/React.createElement("table", {
+      className: this.tableClassNames()
+    }, children), !table && children), footer && /*#__PURE__*/React.createElement("div", {
+      className: "card-footer"
+    }, footer));
+  }
+  bodyClassNames() {
+    const {
+      expandableHide,
+      responsiveTable,
+      table
+    } = digs(this.props, "expandableHide", "responsiveTable", "table");
+    const {
+      expanded
+    } = digs(this.state, "expanded");
+    const classNames = ["card-body"];
+    if (!expanded && expandableHide) {
+      classNames.push("d-none");
+    }
+    if (table) {
+      if (responsiveTable) {
+        classNames.push("table-responsive");
+      }
+      classNames.push("p-0");
+    }
+    return classNames.join(" ");
+  }
+  onCollapseClicked = e => {
+    e.preventDefault();
+    this.setState({
+      expanded: false
+    });
+  };
+  onExpandClicked = e => {
+    e.preventDefault();
+    this.setState({
+      expanded: true
+    });
+  };
+  tableClassNames() {
+    const classNames = ["table", "table-hover", "mb-0", "w-100"];
+    if (this.props.striped) classNames.push("table-striped");
+    return classNames.join(" ");
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","classNames","digg","digs","memo","PropTypes","React","useRef","shapeComponent","ApiMakerBootstrapCard","defaultProps","defaultExpanded","expandable","expandableHide","responsiveTable","table","propTypes","cardRef","object","className","string","children","node","controls","bool","isRequired","footer","header","striped","setup","useStates","expanded","props","render","restProps","state","cardHeaderStyle","display","cardRefToUse","createElement","_extends","Boolean","ref","style","alignSelf","marginRight","href","onClick","bodyClassNames","tableClassNames","push","join","onCollapseClicked","e","preventDefault","setState","onExpandClicked"],"sources":["../../src/bootstrap/card.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport {digg, digs} from \"diggerize\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport React, {useRef} from \"react\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\n\nexport default memo(shapeComponent(class ApiMakerBootstrapCard extends BaseComponent {\n  static defaultProps = {\n    defaultExpanded: true,\n    expandable: false,\n    expandableHide: false,\n    responsiveTable: true,\n    table: false\n  }\n\n  static propTypes = {\n    cardRef: PropTypes.object,\n    className: PropTypes.string,\n    children: PropTypes.node,\n    controls: PropTypes.node,\n    defaultExpanded: PropTypes.bool.isRequired,\n    expandable: PropTypes.bool.isRequired,\n    expandableHide: PropTypes.bool.isRequired,\n    footer: PropTypes.node,\n    header: PropTypes.node,\n    striped: PropTypes.bool,\n    responsiveTable: PropTypes.bool.isRequired,\n    table: PropTypes.bool.isRequired\n  }\n\n  setup() {\n    this.cardRef = useRef()\n\n    this.useStates({\n      expanded: this.props.defaultExpanded\n    })\n  }\n\n  render () {\n    const {\n      cardRef,\n      children,\n      className,\n      controls,\n      defaultExpanded,\n      expandable,\n      expandableHide,\n      footer,\n      header,\n      responsiveTable,\n      striped,\n      table,\n      ...restProps\n    } = this.props\n    const {expanded} = digs(this.state, \"expanded\")\n    const cardHeaderStyle = {display: \"flex\"}\n    const cardRefToUse = cardRef || this.cardRef\n\n    if (!expanded) cardHeaderStyle[\"borderBottom\"] = \"0\"\n\n    return (\n      <div\n        className={classNames(\"component-bootstrap-card\", \"card\", \"card-default\", className)}\n        data-has-footer={Boolean(footer)}\n        ref={cardRefToUse}\n        {...restProps}\n      >\n        {(controls || expandable || header) &&\n          <div className=\"card-header\" style={cardHeaderStyle}>\n            <div className=\"card-header-label\" style={{alignSelf: \"center\", marginRight: \"auto\"}}>\n              {header}\n            </div>\n            {(controls || expandable) &&\n              <div className=\"card-header-actions\" style={{alignSelf: \"center\"}}>\n                {controls}\n                {expandable && expanded &&\n                  <a className=\"collapse-card-button text-muted\" href=\"#\" onClick={digg(this, \"onCollapseClicked\")}>\n                    <i className=\"fa fa-angle-up\" />\n                  </a>\n                }\n                {expandable && !expanded &&\n                  <a className=\"expand-card-button text-muted\" href=\"#\" onClick={digg(this, \"onExpandClicked\")}>\n                    <i className=\"fa fa-angle-down\" />\n                  </a>\n                }\n              </div>\n            }\n          </div>\n        }\n        {(expanded || expandableHide) &&\n          <div className={this.bodyClassNames()}>\n            {table &&\n              <table className={this.tableClassNames()}>\n                {children}\n              </table>\n            }\n            {!table && children}\n          </div>\n        }\n        {footer &&\n          <div className=\"card-footer\">\n            {footer}\n          </div>\n        }\n      </div>\n    )\n  }\n\n  bodyClassNames () {\n    const {expandableHide, responsiveTable, table} = digs(this.props, \"expandableHide\", \"responsiveTable\", \"table\")\n    const {expanded} = digs(this.state, \"expanded\")\n    const classNames = [\"card-body\"]\n\n    if (!expanded && expandableHide) {\n      classNames.push(\"d-none\")\n    }\n\n    if (table) {\n      if (responsiveTable){\n        classNames.push(\"table-responsive\")\n      }\n\n      classNames.push(\"p-0\")\n    }\n\n    return classNames.join(\" \")\n  }\n\n  onCollapseClicked = (e) => {\n    e.preventDefault()\n    this.setState({expanded: false})\n  }\n\n  onExpandClicked = (e) => {\n    e.preventDefault()\n    this.setState({expanded: true})\n  }\n\n  tableClassNames () {\n    const classNames = [\"table\", \"table-hover\", \"mb-0\", \"w-100\"]\n\n    if (this.props.striped)\n      classNames.push(\"table-striped\")\n\n    return classNames.join(\" \")\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/bootstrap/checkbox.js

@@ -0,0 +1,97 @@
+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 { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import Checkbox from "../inputs/checkbox";
+import classNames from "classnames";
+import { digs } from "diggerize";
+import InvalidFeedback from "./invalid-feedback";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import React from "react";
+import useInput from "../use-input";
+export default memo(shapeComponent(class ApiMakerBootstrapCheckbox extends ShapeComponent {
+  static defaultProps = {
+    defaultValue: 1,
+    zeroInput: true
+  };
+  static propTypes = {
+    attribute: PropTypes.string,
+    className: PropTypes.string,
+    defaultChecked: PropTypes.bool,
+    defaultValue: PropTypes.node,
+    hint: PropTypes.node,
+    id: PropTypes.string,
+    label: PropTypes.node,
+    labelClassName: PropTypes.string,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    onChange: PropTypes.func,
+    wrapperClassName: PropTypes.string,
+    zeroInput: PropTypes.bool
+  };
+  setup() {
+    const {
+      inputProps,
+      restProps: useInputRestProps,
+      wrapperOpts
+    } = useInput({
+      props: this.props,
+      wrapperOptions: {
+        type: "checkbox"
+      }
+    });
+    this.setInstance({
+      inputProps,
+      useInputRestProps,
+      wrapperOpts
+    });
+  }
+  render() {
+    const {
+      inputProps,
+      useInputRestProps,
+      wrapperOpts
+    } = this.tt;
+    const {
+      className,
+      hint,
+      id,
+      inputRef,
+      label,
+      labelClassName,
+      wrapperClassName,
+      ...restProps
+    } = useInputRestProps;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    return /*#__PURE__*/React.createElement("div", {
+      className: this.wrapperClassName()
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "form-check"
+    }, /*#__PURE__*/React.createElement(Checkbox, _extends({
+      className: classNames("form-check-input", className, {
+        "is-invalid": errors.length > 0
+      }),
+      id: id,
+      inputRef: inputRef
+    }, restProps)), wrapperOpts.label && /*#__PURE__*/React.createElement("label", {
+      className: this.labelClassName(),
+      htmlFor: inputProps.id
+    }, wrapperOpts.label), hint && /*#__PURE__*/React.createElement("p", {
+      className: "text-muted"
+    }, hint), errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    })));
+  }
+  labelClassName() {
+    const classNames = ["form-check-label"];
+    if (this.props.labelClassName) classNames.push(this.props.labelClassName);
+    return classNames.join(" ");
+  }
+  wrapperClassName() {
+    const classNames = ["component-bootstrap-checkbox", "form-group"];
+    if (this.props.wrapperClassName) classNames.push(this.props.wrapperClassName);
+    return classNames.join(" ");
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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