@kaspernj/api-maker 1.0.446 → 1.0.448

package/build/use-input.js

@@ -0,0 +1,140 @@
+import { dig, digg } from "diggerize";
+import { useCallback, useEffect, useMemo } from "react";
+import idForComponent from "./inputs/id-for-component";
+import nameForComponent from "./inputs/name-for-component";
+import strftime from "strftime";
+import useShape from "set-state-compare/src/use-shape";
+import useValidationErrors from "./use-validation-errors";
+const useInput = ({
+  props,
+  wrapperOptions,
+  ...useInputRestProps
+}) => {
+  const useInputRestPropsKeys = Object.keys(useInputRestProps);
+  if (useInputRestPropsKeys.length > 0) {
+    throw new Error(`Unknown props given to useInput: ${useInputRestPropsKeys.join(", ")}`);
+  }
+  const s = useShape(props);
+  s.useStates({
+    form: undefined
+  });
+  useEffect(() => {
+    setForm();
+  }, [s.props.inputRef?.current]);
+  s.meta.fakeComponent = {
+    props
+  };
+  s.meta.isCheckbox = props.type == "checkbox" || wrapperOptions?.type == "checkbox";
+  s.meta.isSelect = wrapperOptions?.type == "select";
+  const formatValue = useCallback(value => {
+    const {
+      formatValue
+    } = s.props;
+    if (formatValue) {
+      return formatValue(value);
+    } else if (value instanceof Date && !isNaN(value.getTime())) {
+      // We need to use a certain format for datetime-local
+      if (inputType() == "datetime-local") {
+        return strftime("%Y-%m-%dT%H:%M:%S", value);
+      } else if (inputType() == "date") {
+        return strftime("%Y-%m-%d", value);
+      }
+    }
+    return value;
+  }, []);
+  const inputDefaultChecked = useCallback(() => {
+    if ("defaultChecked" in s.props) {
+      return s.props.defaultChecked;
+    } else if (s.props.attribute && s.props.model) {
+      if (!s.props.model[s.props.attribute]) throw new Error(`No such attribute: ${s.props.attribute}`);
+      return s.props.model[s.props.attribute]();
+    }
+  }, []);
+  const inputDefaultValue = useCallback(() => {
+    if ("defaultValue" in s.props) {
+      return formatValue(s.props.defaultValue);
+    } else if (s.props.model && s.props.attribute) {
+      if (!s.props.model[s.props.attribute]) {
+        throw new Error(`No such attribute defined on resource: ${digg(s.props.model.modelClassData(), "name")}#${s.props.attribute}`);
+      }
+      return formatValue(s.props.model[s.props.attribute]());
+    }
+  }, []);
+  const inputRefBackup = useCallback(() => {
+    if (!s.meta._inputRefBackup) s.meta._inputRefBackup = React.createRef();
+    return s.meta._inputRefBackup;
+  }, []);
+  const inputRef = useCallback(() => s.props.inputRef || inputRefBackup());
+  const inputType = useCallback(() => {
+    if ("type" in s.props) {
+      return s.props.type;
+    } else if (s.m.isCheckbox) {
+      return "checkbox";
+    } else {
+      return "text";
+    }
+  }, []);
+  const label = useCallback(() => {
+    if ("label" in s.props) {
+      return s.props.label;
+    } else if (s.props.attribute && s.props.model) {
+      return s.props.model.modelClass().humanAttributeName(s.props.attribute);
+    }
+  }, []);
+  const setForm = useCallback(() => {
+    const inputElement = inputRef().current;
+    let form;
+    if (inputElement) form = dig(inputElement, "form");
+    if (form && form != s.s.form) s.set({
+      form
+    });
+  }, []);
+  const getId = useCallback(() => idForComponent(s.m.fakeComponent), []);
+  const getName = useCallback(() => nameForComponent(s.m.fakeComponent), []);
+  const getInputProps = useCallback(() => {
+    const givenInputProps = s.props.inputProps || {};
+    const inputProps = Object.assign({
+      id: getId(),
+      name: getName(),
+      ref: inputRef()
+    }, givenInputProps);
+    if (s.m.isCheckbox) {
+      if ("checked" in s.props) {
+        inputProps.checked = s.props.checked;
+      }
+      if ("defaultChecked" in s.props || s.props.attribute && s.props.model) {
+        inputProps.defaultChecked = inputDefaultChecked();
+      }
+    } else if ("value" in s.props) {
+      inputProps.value = s.props.value;
+    } else if (!("value" in s.props)) {
+      inputProps.defaultValue = inputDefaultValue();
+    }
+    return inputProps;
+  }, []);
+  const {
+    inputProps: oldInputProps,
+    wrapperOpts: oldWrapperOpts,
+    ...restProps
+  } = props;
+  const type = inputType();
+  s.meta.inputProps = getInputProps();
+  s.meta.inputNameWithoutId = useMemo(() => s.m.inputProps.name?.replace(/\[(.+)_id\]$/, "[$1]"), [s.m.inputProps.name]);
+  if (!s.m.inputProps.ref) throw new Error("No input ref?");
+  if (!s.m.isSelect) s.m.inputProps.type = type;
+  const {
+    validationErrors
+  } = useValidationErrors(validationError => validationError.inputName == s.m.inputProps.name || validationError.inputName == s.m.inputNameWithoutId);
+  const wrapperOpts = {
+    errors: validationErrors,
+    form: s.s.form,
+    label: label()
+  };
+  return {
+    inputProps: s.m.inputProps,
+    wrapperOpts,
+    restProps
+  };
+};
+export default useInput;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["dig","digg","useCallback","useEffect","useMemo","idForComponent","nameForComponent","strftime","useShape","useValidationErrors","useInput","props","wrapperOptions","useInputRestProps","useInputRestPropsKeys","Object","keys","length","Error","join","s","useStates","form","undefined","setForm","inputRef","current","meta","fakeComponent","isCheckbox","type","isSelect","formatValue","value","Date","isNaN","getTime","inputType","inputDefaultChecked","defaultChecked","attribute","model","inputDefaultValue","defaultValue","modelClassData","inputRefBackup","_inputRefBackup","React","createRef","m","label","modelClass","humanAttributeName","inputElement","set","getId","getName","getInputProps","givenInputProps","inputProps","assign","id","name","ref","checked","oldInputProps","wrapperOpts","oldWrapperOpts","restProps","inputNameWithoutId","replace","validationErrors","validationError","inputName","errors"],"sources":["../src/use-input.js"],"sourcesContent":["import {dig, digg} from \"diggerize\"\nimport {useCallback, useEffect, useMemo} from \"react\"\nimport idForComponent from \"./inputs/id-for-component\"\nimport nameForComponent from \"./inputs/name-for-component\"\nimport strftime from \"strftime\"\nimport useShape from \"set-state-compare/src/use-shape\"\nimport useValidationErrors from \"./use-validation-errors\"\n\nconst useInput = ({props, wrapperOptions, ...useInputRestProps}) => {\n  const useInputRestPropsKeys = Object.keys(useInputRestProps)\n\n  if (useInputRestPropsKeys.length > 0) {\n    throw new Error(`Unknown props given to useInput: ${useInputRestPropsKeys.join(\", \")}`)\n  }\n\n  const s = useShape(props)\n\n  s.useStates({\n    form: undefined\n  })\n\n  useEffect(() => {\n    setForm()\n  }, [s.props.inputRef?.current])\n\n  s.meta.fakeComponent = {props}\n  s.meta.isCheckbox = props.type == \"checkbox\" || wrapperOptions?.type == \"checkbox\"\n  s.meta.isSelect = wrapperOptions?.type == \"select\"\n\n  const formatValue = useCallback((value) => {\n    const {formatValue} = s.props\n\n    if (formatValue) {\n      return formatValue(value)\n    } else if (value instanceof Date && !isNaN(value.getTime())) {\n      // We need to use a certain format for datetime-local\n      if (inputType() == \"datetime-local\") {\n        return strftime(\"%Y-%m-%dT%H:%M:%S\", value)\n      } else if (inputType() == \"date\") {\n        return strftime(\"%Y-%m-%d\", value)\n      }\n    }\n\n    return value\n  }, [])\n\n  const inputDefaultChecked = useCallback(() => {\n    if (\"defaultChecked\" in s.props) {\n      return s.props.defaultChecked\n    } else if (s.props.attribute && s.props.model) {\n      if (!s.props.model[s.props.attribute])\n        throw new Error(`No such attribute: ${s.props.attribute}`)\n\n      return s.props.model[s.props.attribute]()\n    }\n  }, [])\n\n  const inputDefaultValue = useCallback(() => {\n    if (\"defaultValue\" in s.props) {\n      return formatValue(s.props.defaultValue)\n    } else if (s.props.model && s.props.attribute) {\n      if (!s.props.model[s.props.attribute]) {\n        throw new Error(`No such attribute defined on resource: ${digg(s.props.model.modelClassData(), \"name\")}#${s.props.attribute}`)\n      }\n\n      return formatValue(s.props.model[s.props.attribute]())\n    }\n  }, [])\n\n  const inputRefBackup = useCallback(() => {\n    if (!s.meta._inputRefBackup) s.meta._inputRefBackup = React.createRef()\n\n    return s.meta._inputRefBackup\n  }, [])\n\n  const inputRef = useCallback(() => s.props.inputRef || inputRefBackup())\n\n  const inputType = useCallback(() => {\n    if (\"type\" in s.props) {\n      return s.props.type\n    } else if (s.m.isCheckbox) {\n      return \"checkbox\"\n    } else {\n      return \"text\"\n    }\n  }, [])\n\n  const label = useCallback(() => {\n    if (\"label\" in s.props) {\n      return s.props.label\n    } else if (s.props.attribute && s.props.model) {\n      return s.props.model.modelClass().humanAttributeName(s.props.attribute)\n    }\n  }, [])\n\n  const setForm = useCallback(() => {\n    const inputElement = inputRef().current\n\n    let form\n\n    if (inputElement) form = dig(inputElement, \"form\")\n    if (form && form != s.s.form) s.set({form})\n  }, [])\n\n  const getId = useCallback(() => idForComponent(s.m.fakeComponent), [])\n  const getName = useCallback(() => nameForComponent(s.m.fakeComponent), [])\n\n  const getInputProps = useCallback(() => {\n    const givenInputProps = s.props.inputProps || {}\n    const inputProps = Object.assign(\n      {\n        id: getId(),\n        name: getName(),\n        ref: inputRef()\n      },\n      givenInputProps\n    )\n\n    if (s.m.isCheckbox) {\n      if (\"checked\" in s.props) {\n        inputProps.checked = s.props.checked\n      }\n\n      if (\"defaultChecked\" in s.props || (s.props.attribute && s.props.model)) {\n        inputProps.defaultChecked = inputDefaultChecked()\n      }\n    } else if (\"value\" in s.props) {\n      inputProps.value = s.props.value\n    } else if (!(\"value\" in s.props)) {\n      inputProps.defaultValue = inputDefaultValue()\n    }\n\n    return inputProps\n  }, [])\n\n  const {inputProps: oldInputProps, wrapperOpts: oldWrapperOpts, ...restProps} = props\n  const type = inputType()\n\n  s.meta.inputProps = getInputProps()\n  s.meta.inputNameWithoutId = useMemo(() => s.m.inputProps.name?.replace(/\\[(.+)_id\\]$/, \"[$1]\"), [s.m.inputProps.name])\n\n  if (!s.m.inputProps.ref) throw new Error(\"No input ref?\")\n  if (!s.m.isSelect) s.m.inputProps.type = type\n\n  const {validationErrors} = useValidationErrors((validationError) =>\n    validationError.inputName == s.m.inputProps.name || validationError.inputName == s.m.inputNameWithoutId\n  )\n\n  const wrapperOpts = {\n    errors: validationErrors,\n    form: s.s.form,\n    label: label()\n  }\n\n  return {\n    inputProps: s.m.inputProps,\n    wrapperOpts,\n    restProps\n  }\n}\n\nexport default useInput\n"],"mappings":"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","ignoreList":[]}

package/build/use-model-event.js

@@ -0,0 +1,60 @@
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import debounceFunction from "debounce";
+import ModelEvents from "./model-events";
+import useShape from "set-state-compare/src/use-shape";
+const apiMakerUseModelEvent = (model, event, onCallback, props) => {
+  const {
+    active = true,
+    debounce,
+    onConnected,
+    ...restProps
+  } = props || {};
+  if (Object.keys(restProps).length > 0) {
+    throw new Error(`Unknown props given to apiMakerUseModelEvent: ${Object.keys(restProps).join(", ")}`);
+  }
+  const s = useShape({
+    active,
+    debounce,
+    model,
+    onCallback
+  });
+  const debounceCallback = useMemo(() => {
+    if (typeof debounce == "number") {
+      return debounceFunction(s.p.onCallback, debounce);
+    } else {
+      return debounceFunction(s.p.onCallback);
+    }
+  }, [debounce]);
+  s.updateMeta({
+    debounceCallback
+  });
+  const onCallbackCallback = useCallback((...args) => {
+    if (!s.p.active) {
+      return;
+    }
+    if (s.p.debounce) {
+      s.m.debounceCallback(...args);
+    } else {
+      s.p.onCallback(...args);
+    }
+  }, []);
+  useLayoutEffect(() => {
+    let connectEvent, onConnectedListener;
+    if (model) {
+      connectEvent = ModelEvents.connect(model, event, onCallbackCallback);
+      if (onConnected) {
+        onConnectedListener = connectEvent.events.addListener("connected", onConnected);
+      }
+    }
+    return () => {
+      if (onConnectedListener) {
+        connectEvent.events.removeListener("connected", onConnected);
+      }
+      if (connectEvent) {
+        connectEvent.unsubscribe();
+      }
+    };
+  }, [model?.id()]);
+};
+export default apiMakerUseModelEvent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VDYWxsYmFjayIsInVzZUxheW91dEVmZmVjdCIsInVzZU1lbW8iLCJkZWJvdW5jZUZ1bmN0aW9uIiwiTW9kZWxFdmVudHMiLCJ1c2VTaGFwZSIsImFwaU1ha2VyVXNlTW9kZWxFdmVudCIsIm1vZGVsIiwiZXZlbnQiLCJvbkNhbGxiYWNrIiwicHJvcHMiLCJhY3RpdmUiLCJkZWJvdW5jZSIsIm9uQ29ubmVjdGVkIiwicmVzdFByb3BzIiwiT2JqZWN0Iiwia2V5cyIsImxlbmd0aCIsIkVycm9yIiwiam9pbiIsInMiLCJkZWJvdW5jZUNhbGxiYWNrIiwicCIsInVwZGF0ZU1ldGEiLCJvbkNhbGxiYWNrQ2FsbGJhY2siLCJhcmdzIiwibSIsImNvbm5lY3RFdmVudCIsIm9uQ29ubmVjdGVkTGlzdGVuZXIiLCJjb25uZWN0IiwiZXZlbnRzIiwiYWRkTGlzdGVuZXIiLCJyZW1vdmVMaXN0ZW5lciIsInVuc3Vic2NyaWJlIiwiaWQiXSwic291cmNlcyI6WyIuLi9zcmMvdXNlLW1vZGVsLWV2ZW50LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7dXNlQ2FsbGJhY2ssIHVzZUxheW91dEVmZmVjdCwgdXNlTWVtb30gZnJvbSBcInJlYWN0XCJcbmltcG9ydCBkZWJvdW5jZUZ1bmN0aW9uIGZyb20gXCJkZWJvdW5jZVwiXG5pbXBvcnQgTW9kZWxFdmVudHMgZnJvbSBcIi4vbW9kZWwtZXZlbnRzXCJcbmltcG9ydCB1c2VTaGFwZSBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL3VzZS1zaGFwZVwiXG5cbmNvbnN0IGFwaU1ha2VyVXNlTW9kZWxFdmVudCA9IChtb2RlbCwgZXZlbnQsIG9uQ2FsbGJhY2ssIHByb3BzKSA9PiB7XG4gIGNvbnN0IHthY3RpdmUgPSB0cnVlLCBkZWJvdW5jZSwgb25Db25uZWN0ZWQsIC4uLnJlc3RQcm9wc30gPSBwcm9wcyB8fCB7fVxuXG4gIGlmIChPYmplY3Qua2V5cyhyZXN0UHJvcHMpLmxlbmd0aCA+IDApIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYFVua25vd24gcHJvcHMgZ2l2ZW4gdG8gYXBpTWFrZXJVc2VNb2RlbEV2ZW50OiAke09iamVjdC5rZXlzKHJlc3RQcm9wcykuam9pbihcIiwgXCIpfWApXG4gIH1cblxuICBjb25zdCBzID0gdXNlU2hhcGUoe2FjdGl2ZSwgZGVib3VuY2UsIG1vZGVsLCBvbkNhbGxiYWNrfSlcblxuICBjb25zdCBkZWJvdW5jZUNhbGxiYWNrID0gdXNlTWVtbygoKSA9PiB7XG4gICAgaWYgKHR5cGVvZiBkZWJvdW5jZSA9PSBcIm51bWJlclwiKSB7XG4gICAgICByZXR1cm4gZGVib3VuY2VGdW5jdGlvbihzLnAub25DYWxsYmFjaywgZGVib3VuY2UpXG4gICAgfSBlbHNlIHtcbiAgICAgIHJldHVybiBkZWJvdW5jZUZ1bmN0aW9uKHMucC5vbkNhbGxiYWNrKVxuICAgIH1cbiAgfSwgW2RlYm91bmNlXSlcblxuICBzLnVwZGF0ZU1ldGEoe2RlYm91bmNlQ2FsbGJhY2t9KVxuXG4gIGNvbnN0IG9uQ2FsbGJhY2tDYWxsYmFjayA9IHVzZUNhbGxiYWNrKCguLi5hcmdzKSA9PiB7XG4gICAgaWYgKCFzLnAuYWN0aXZlKSB7XG4gICAgICByZXR1cm5cbiAgICB9XG5cbiAgICBpZiAocy5wLmRlYm91bmNlKSB7XG4gICAgICBzLm0uZGVib3VuY2VDYWxsYmFjayguLi5hcmdzKVxuICAgIH0gZWxzZSB7XG4gICAgICBzLnAub25DYWxsYmFjayguLi5hcmdzKVxuICAgIH1cbiAgfSwgW10pXG5cbiAgdXNlTGF5b3V0RWZmZWN0KCgpID0+IHtcbiAgICBsZXQgY29ubmVjdEV2ZW50LCBvbkNvbm5lY3RlZExpc3RlbmVyXG5cbiAgICBpZiAobW9kZWwpIHtcbiAgICAgIGNvbm5lY3RFdmVudCA9IE1vZGVsRXZlbnRzLmNvbm5lY3QobW9kZWwsIGV2ZW50LCBvbkNhbGxiYWNrQ2FsbGJhY2spXG5cbiAgICAgIGlmIChvbkNvbm5lY3RlZCkge1xuICAgICAgICBvbkNvbm5lY3RlZExpc3RlbmVyID0gY29ubmVjdEV2ZW50LmV2ZW50cy5hZGRMaXN0ZW5lcihcImNvbm5lY3RlZFwiLCBvbkNvbm5lY3RlZClcbiAgICAgIH1cbiAgICB9XG5cbiAgICByZXR1cm4gKCkgPT4ge1xuICAgICAgaWYgKG9uQ29ubmVjdGVkTGlzdGVuZXIpIHtcbiAgICAgICAgY29ubmVjdEV2ZW50LmV2ZW50cy5yZW1vdmVMaXN0ZW5lcihcImNvbm5lY3RlZFwiLCBvbkNvbm5lY3RlZClcbiAgICAgIH1cblxuICAgICAgaWYgKGNvbm5lY3RFdmVudCkge1xuICAgICAgICBjb25uZWN0RXZlbnQudW5zdWJzY3JpYmUoKVxuICAgICAgfVxuICAgIH1cbiAgfSwgW21vZGVsPy5pZCgpXSlcbn1cblxuZXhwb3J0IGRlZmF1bHQgYXBpTWFrZXJVc2VNb2RlbEV2ZW50XG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVFBLFdBQVcsRUFBRUMsZUFBZSxFQUFFQyxPQUFPLFFBQU8sT0FBTztBQUMzRCxPQUFPQyxnQkFBZ0IsTUFBTSxVQUFVO0FBQ3ZDLE9BQU9DLFdBQVcsTUFBTSxnQkFBZ0I7QUFDeEMsT0FBT0MsUUFBUSxNQUFNLGlDQUFpQztBQUV0RCxNQUFNQyxxQkFBcUIsR0FBR0EsQ0FBQ0MsS0FBSyxFQUFFQyxLQUFLLEVBQUVDLFVBQVUsRUFBRUMsS0FBSyxLQUFLO0VBQ2pFLE1BQU07SUFBQ0MsTUFBTSxHQUFHLElBQUk7SUFBRUMsUUFBUTtJQUFFQyxXQUFXO0lBQUUsR0FBR0M7RUFBUyxDQUFDLEdBQUdKLEtBQUssSUFBSSxDQUFDLENBQUM7RUFFeEUsSUFBSUssTUFBTSxDQUFDQyxJQUFJLENBQUNGLFNBQVMsQ0FBQyxDQUFDRyxNQUFNLEdBQUcsQ0FBQyxFQUFFO0lBQ3JDLE1BQU0sSUFBSUMsS0FBSyxDQUFDLGlEQUFpREgsTUFBTSxDQUFDQyxJQUFJLENBQUNGLFNBQVMsQ0FBQyxDQUFDSyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztFQUN2RztFQUVBLE1BQU1DLENBQUMsR0FBR2YsUUFBUSxDQUFDO0lBQUNNLE1BQU07SUFBRUMsUUFBUTtJQUFFTCxLQUFLO0lBQUVFO0VBQVUsQ0FBQyxDQUFDO0VBRXpELE1BQU1ZLGdCQUFnQixHQUFHbkIsT0FBTyxDQUFDLE1BQU07SUFDckMsSUFBSSxPQUFPVSxRQUFRLElBQUksUUFBUSxFQUFFO01BQy9CLE9BQU9ULGdCQUFnQixDQUFDaUIsQ0FBQyxDQUFDRSxDQUFDLENBQUNiLFVBQVUsRUFBRUcsUUFBUSxDQUFDO0lBQ25ELENBQUMsTUFBTTtNQUNMLE9BQU9ULGdCQUFnQixDQUFDaUIsQ0FBQyxDQUFDRSxDQUFDLENBQUNiLFVBQVUsQ0FBQztJQUN6QztFQUNGLENBQUMsRUFBRSxDQUFDRyxRQUFRLENBQUMsQ0FBQztFQUVkUSxDQUFDLENBQUNHLFVBQVUsQ0FBQztJQUFDRjtFQUFnQixDQUFDLENBQUM7RUFFaEMsTUFBTUcsa0JBQWtCLEdBQUd4QixXQUFXLENBQUMsQ0FBQyxHQUFHeUIsSUFBSSxLQUFLO0lBQ2xELElBQUksQ0FBQ0wsQ0FBQyxDQUFDRSxDQUFDLENBQUNYLE1BQU0sRUFBRTtNQUNmO0lBQ0Y7SUFFQSxJQUFJUyxDQUFDLENBQUNFLENBQUMsQ0FBQ1YsUUFBUSxFQUFFO01BQ2hCUSxDQUFDLENBQUNNLENBQUMsQ0FBQ0wsZ0JBQWdCLENBQUMsR0FBR0ksSUFBSSxDQUFDO0lBQy9CLENBQUMsTUFBTTtNQUNMTCxDQUFDLENBQUNFLENBQUMsQ0FBQ2IsVUFBVSxDQUFDLEdBQUdnQixJQUFJLENBQUM7SUFDekI7RUFDRixDQUFDLEVBQUUsRUFBRSxDQUFDO0VBRU54QixlQUFlLENBQUMsTUFBTTtJQUNwQixJQUFJMEIsWUFBWSxFQUFFQyxtQkFBbUI7SUFFckMsSUFBSXJCLEtBQUssRUFBRTtNQUNUb0IsWUFBWSxHQUFHdkIsV0FBVyxDQUFDeUIsT0FBTyxDQUFDdEIsS0FBSyxFQUFFQyxLQUFLLEVBQUVnQixrQkFBa0IsQ0FBQztNQUVwRSxJQUFJWCxXQUFXLEVBQUU7UUFDZmUsbUJBQW1CLEdBQUdELFlBQVksQ0FBQ0csTUFBTSxDQUFDQyxXQUFXLENBQUMsV0FBVyxFQUFFbEIsV0FBVyxDQUFDO01BQ2pGO0lBQ0Y7SUFFQSxPQUFPLE1BQU07TUFDWCxJQUFJZSxtQkFBbUIsRUFBRTtRQUN2QkQsWUFBWSxDQUFDRyxNQUFNLENBQUNFLGNBQWMsQ0FBQyxXQUFXLEVBQUVuQixXQUFXLENBQUM7TUFDOUQ7TUFFQSxJQUFJYyxZQUFZLEVBQUU7UUFDaEJBLFlBQVksQ0FBQ00sV0FBVyxDQUFDLENBQUM7TUFDNUI7SUFDRixDQUFDO0VBQ0gsQ0FBQyxFQUFFLENBQUMxQixLQUFLLEVBQUUyQixFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbkIsQ0FBQztBQUVELGVBQWU1QixxQkFBcUIiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/use-model.js

@@ -0,0 +1,169 @@
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import Devise from "./devise";
+import * as inflection from "inflection";
+import ModelEvents from "./model-events";
+import useQueryParams from "on-location-changed/src/use-query-params";
+import useShape from "set-state-compare/src/use-shape";
+const useModel = (modelClassArg, argsArg = {}) => {
+  const queryParams = useQueryParams();
+  let args, modelClass;
+  if (typeof argsArg == "function") {
+    args = argsArg({
+      modelClass
+    });
+  } else {
+    args = argsArg;
+  }
+  const s = useShape(args);
+  s.useStates({
+    model: undefined,
+    notFound: undefined
+  });
+  if ("active" in s.props && !s.props.active) {
+    s.meta.active = false;
+  } else {
+    s.meta.active = true;
+  }
+  if (typeof modelClassArg == "object") {
+    modelClass = modelClassArg.callback({
+      queryParams
+    });
+  } else {
+    modelClass = modelClassArg;
+  }
+  const paramsVariableName = `${modelClass.modelName().paramKey()}_id`;
+  let modelId;
+  if (args.loadByQueryParam) {
+    modelId = args.loadByQueryParam({
+      queryParams
+    });
+  } else if (!args.query) {
+    if (!args.match) throw new Error("Both 'loadByQueryParam' and 'match' wasn't given");
+    modelId = args.match.params[paramsVariableName] || args.match.params.id;
+  }
+  const modelVariableName = inflection.camelize(modelClass.modelClassData().name, true);
+  const cacheArgs = [modelId];
+  const loadExistingModel = useCallback(async () => {
+    let query;
+    if (s.m.modelId) {
+      query = modelClass.ransack({
+        id_eq: s.m.modelId
+      });
+    } else if (s.m.args.query) {
+      query = s.m.args.query.clone();
+    } else {
+      throw new Error(`No model ID was given: ${s.m.modelId} by '${paramsVariableName}' in query params: ${Object.keys(s.props.match.params).join(", ")}`);
+    }
+    if (s.props.abilities) query.abilities(s.p.abilities);
+    if (s.props.preload) query.preload(s.p.preload);
+    if (s.props.select) query.select(s.p.select);
+    const model = await query.first();
+    s.set({
+      model,
+      notFound: !model
+    });
+  }, []);
+  const loadNewModel = useCallback(async () => {
+    const ModelClass = modelClass;
+    const paramKey = ModelClass.modelName().paramKey();
+    const modelDataFromParams = s.m.queryParams[paramKey] || {};
+    let defaults = {};
+    if (s.props.newIfNoId?.defaults) {
+      defaults = await s.props.newIfNoId.defaults();
+    }
+    const modelData = Object.assign(defaults, s.props.newAttributes, modelDataFromParams);
+    const model = new ModelClass({
+      isNewRecord: true,
+      data: {
+        a: modelData
+      }
+    });
+    s.set({
+      model
+    });
+  }, []);
+  const loadModel = useCallback(async () => {
+    if (!s.m.active) {
+      // Not active - don't do anything
+    } else if (s.props.newIfNoId && !s.m.modelId) {
+      return await loadNewModel();
+    } else if (!s.props.optional || s.m.modelId | s.m.args.query) {
+      return await loadExistingModel();
+    }
+  }, []);
+  const onDestroyed = useCallback(({
+    model
+  }) => {
+    const forwardArgs = {
+      model
+    };
+    forwardArgs[s.m.modelVariableName] = model;
+    s.p.onDestroyed(forwardArgs);
+  }, []);
+  const onSignedIn = useCallback(() => {
+    loadModel();
+  }, []);
+  const onSignedOut = useCallback(() => {
+    loadModel();
+  }, []);
+  if (args.cacheArgs) {
+    cacheArgs.push(...args.cacheArgs);
+  }
+  s.updateMeta({
+    args,
+    modelId,
+    modelVariableName,
+    queryParams
+  });
+  useMemo(() => {
+    loadModel();
+  }, cacheArgs);
+  useLayoutEffect(() => {
+    let reloadModelCallback;
+    if (args.events) {
+      reloadModelCallback = args.events.addListener("reloadModel", loadModel);
+    }
+    return () => {
+      if (reloadModelCallback) {
+        args.events.removeListener("reloadModel", loadModel);
+      }
+    };
+  }, [args.events]);
+  useLayoutEffect(() => {
+    let connectUpdated;
+    if (s.s.model && args.eventUpdated) {
+      connectUpdated = ModelEvents.connectUpdated(s.s.model, loadModel);
+    }
+    return () => {
+      connectUpdated?.unsubscribe();
+    };
+  }, [args.eventUpdated, s.s.model?.id()]);
+  useLayoutEffect(() => {
+    Devise.events().addListener("onDeviseSignIn", onSignedIn);
+    Devise.events().addListener("onDeviseSignOut", onSignedOut);
+    return () => {
+      Devise.events().removeListener("onDeviseSignIn", onSignedIn);
+      Devise.events().removeListener("onDeviseSignOut", onSignedOut);
+    };
+  });
+  useLayoutEffect(() => {
+    let connectDestroyed;
+    if (s.s.model && args.onDestroyed) {
+      connectDestroyed = ModelEvents.connectDestroyed(s.s.model, onDestroyed);
+    }
+    return () => {
+      connectDestroyed?.unsubscribe();
+    };
+  }, [args.onDestroyed, s.s.model?.id()]);
+  const result = {
+    model: s.s.model,
+    modelId,
+    notFound: s.s.notFound
+  };
+  result[modelVariableName] = s.s.model;
+  result[`${modelVariableName}Id`] = modelId;
+  result[`${modelVariableName}NotFound`] = s.s.notFound;
+  return result;
+};
+export default useModel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useCallback","useLayoutEffect","useMemo","Devise","inflection","ModelEvents","useQueryParams","useShape","useModel","modelClassArg","argsArg","queryParams","args","modelClass","s","useStates","model","undefined","notFound","props","active","meta","callback","paramsVariableName","modelName","paramKey","modelId","loadByQueryParam","query","match","Error","params","id","modelVariableName","camelize","modelClassData","name","cacheArgs","loadExistingModel","m","ransack","id_eq","clone","Object","keys","join","abilities","p","preload","select","first","set","loadNewModel","ModelClass","modelDataFromParams","defaults","newIfNoId","modelData","assign","newAttributes","isNewRecord","data","a","loadModel","optional","onDestroyed","forwardArgs","onSignedIn","onSignedOut","push","updateMeta","reloadModelCallback","events","addListener","removeListener","connectUpdated","eventUpdated","unsubscribe","connectDestroyed","result"],"sources":["../src/use-model.js"],"sourcesContent":["import {useCallback, useLayoutEffect, useMemo} from \"react\"\nimport Devise from \"./devise\"\nimport * as inflection from \"inflection\"\nimport ModelEvents from \"./model-events\"\nimport useQueryParams from \"on-location-changed/src/use-query-params\"\nimport useShape from \"set-state-compare/src/use-shape\"\n\nconst useModel = (modelClassArg, argsArg = {}) => {\n  const queryParams = useQueryParams()\n  let args, modelClass\n\n  if (typeof argsArg == \"function\") {\n    args = argsArg({modelClass})\n  } else {\n    args = argsArg\n  }\n\n  const s = useShape(args)\n\n  s.useStates({\n    model: undefined,\n    notFound: undefined\n  })\n\n  if (\"active\" in s.props && !s.props.active) {\n    s.meta.active = false\n  } else {\n    s.meta.active = true\n  }\n\n  if (typeof modelClassArg == \"object\") {\n    modelClass = modelClassArg.callback({queryParams})\n  } else {\n    modelClass = modelClassArg\n  }\n\n  const paramsVariableName = `${modelClass.modelName().paramKey()}_id`\n  let modelId\n\n  if (args.loadByQueryParam) {\n    modelId = args.loadByQueryParam({queryParams})\n  } else if (!args.query) {\n    if (!args.match) throw new Error(\"Both 'loadByQueryParam' and 'match' wasn't given\")\n\n    modelId = args.match.params[paramsVariableName] || args.match.params.id\n  }\n\n  const modelVariableName = inflection.camelize(modelClass.modelClassData().name, true)\n  const cacheArgs = [modelId]\n\n  const loadExistingModel = useCallback(async () => {\n    let query\n\n    if (s.m.modelId) {\n      query = modelClass.ransack({id_eq: s.m.modelId})\n    } else if (s.m.args.query) {\n      query = s.m.args.query.clone()\n    } else {\n      throw new Error(`No model ID was given: ${s.m.modelId} by '${paramsVariableName}' in query params: ${Object.keys(s.props.match.params).join(\", \")}`)\n    }\n\n    if (s.props.abilities) query.abilities(s.p.abilities)\n    if (s.props.preload) query.preload(s.p.preload)\n    if (s.props.select) query.select(s.p.select)\n\n    const model = await query.first()\n\n    s.set({model, notFound: !model})\n  }, [])\n\n  const loadNewModel = useCallback(async () => {\n    const ModelClass = modelClass\n    const paramKey = ModelClass.modelName().paramKey()\n    const modelDataFromParams = s.m.queryParams[paramKey] || {}\n\n    let defaults = {}\n\n    if (s.props.newIfNoId?.defaults) {\n      defaults = await s.props.newIfNoId.defaults()\n    }\n\n    const modelData = Object.assign(defaults, s.props.newAttributes, modelDataFromParams)\n    const model = new ModelClass({\n      isNewRecord: true,\n      data: {a: modelData}\n    })\n\n    s.set({model})\n  }, [])\n\n  const loadModel = useCallback(async () => {\n    if (!s.m.active) {\n      // Not active - don't do anything\n    } else if (s.props.newIfNoId && !s.m.modelId) {\n      return await loadNewModel()\n    } else if (!s.props.optional || s.m.modelId | s.m.args.query) {\n      return await loadExistingModel()\n    }\n  }, [])\n\n  const onDestroyed = useCallback(({model}) => {\n    const forwardArgs = {model}\n\n    forwardArgs[s.m.modelVariableName] = model\n\n    s.p.onDestroyed(forwardArgs)\n  }, [])\n\n  const onSignedIn = useCallback(() => {\n    loadModel()\n  }, [])\n\n  const onSignedOut = useCallback(() => {\n    loadModel()\n  }, [])\n\n  if (args.cacheArgs) {\n    cacheArgs.push(...args.cacheArgs)\n  }\n\n  s.updateMeta({args, modelId, modelVariableName, queryParams})\n\n  useMemo(\n    () => { loadModel() },\n    cacheArgs\n  )\n\n  useLayoutEffect(() => {\n    let reloadModelCallback\n\n    if (args.events) {\n      reloadModelCallback = args.events.addListener(\"reloadModel\", loadModel)\n    }\n\n    return () => {\n      if (reloadModelCallback) {\n        args.events.removeListener(\"reloadModel\", loadModel)\n      }\n    }\n  }, [args.events])\n\n  useLayoutEffect(() => {\n    let connectUpdated\n\n    if (s.s.model && args.eventUpdated) {\n      connectUpdated = ModelEvents.connectUpdated(s.s.model, loadModel)\n    }\n\n    return () => {\n      connectUpdated?.unsubscribe()\n    }\n  }, [args.eventUpdated, s.s.model?.id()])\n\n  useLayoutEffect(() => {\n    Devise.events().addListener(\"onDeviseSignIn\", onSignedIn)\n    Devise.events().addListener(\"onDeviseSignOut\", onSignedOut)\n\n    return () => {\n      Devise.events().removeListener(\"onDeviseSignIn\", onSignedIn)\n      Devise.events().removeListener(\"onDeviseSignOut\", onSignedOut)\n    }\n  })\n\n  useLayoutEffect(() => {\n    let connectDestroyed\n\n    if (s.s.model && args.onDestroyed) {\n      connectDestroyed = ModelEvents.connectDestroyed(s.s.model, onDestroyed)\n    }\n\n    return () => {\n      connectDestroyed?.unsubscribe()\n    }\n  }, [args.onDestroyed, s.s.model?.id()])\n\n  const result = {\n    model: s.s.model,\n    modelId,\n    notFound: s.s.notFound\n  }\n\n  result[modelVariableName] = s.s.model\n  result[`${modelVariableName}Id`] = modelId\n  result[`${modelVariableName}NotFound`] = s.s.notFound\n\n  return result\n}\n\nexport default useModel\n"],"mappings":"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","ignoreList":[]}

package/build/use-resize-observer.js

@@ -0,0 +1,23 @@
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import useShape from "set-state-compare/src/use-shape";
+const useResizeObserver = (element, callback) => {
+  const s = useShape({
+    callback
+  });
+  const onResize = useCallback((...args) => {
+    s.p.callback(...args);
+  }, []);
+  const observer = useMemo(() => new ResizeObserver(onResize), []);
+  useLayoutEffect(() => {
+    if (element) {
+      observer.observe(element);
+    }
+    return () => {
+      if (element) {
+        observer.disconnect();
+      }
+    };
+  }, [element]);
+};
+export default useResizeObserver;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/use-router.js

@@ -0,0 +1,102 @@
+import config from "./config";
+import escapeStringRegexp from "escape-string-regexp";
+import * as inflection from "inflection";
+import PropTypes from "prop-types";
+import { useCallback, useMemo } from "react";
+import useShape from "set-state-compare/src/use-shape";
+const useRouter = props => {
+  const s = useShape(props);
+  const findRouteParams = useCallback(routeDefinition => {
+    const result = [];
+    const parts = routeDefinition.path.split("/");
+    for (const part of parts) {
+      if (part.match(/^:([a-z_]+)$/)) result.push(part);
+    }
+    return result;
+  }, []);
+  const getPath = useCallback(() => {
+    let path = s.p.path || window.location.pathname;
+    path = path.replace(/[/]+$/, "");
+    return path;
+  }, []);
+  const getRouteDefinitions = useCallback(() => s.p.routeDefinitions || config.getRouteDefinitions(), []);
+  const getRoutes = useCallback(() => s.p.routes || config.getRoutes(), []);
+  const parseRouteDefinitions = useCallback(() => {
+    const Locales = require("shared/locales").default;
+    const routeDefinitions = getRouteDefinitions();
+    const routes = getRoutes();
+    const regex = /:([A-z\d_]+)/;
+    const parsedRouteDefinitions = [];
+    for (const locale of Locales.availableLocales()) {
+      for (const routeDefinition of routeDefinitions.routes) {
+        const routePathName = `${inflection.camelize(routeDefinition.name, true)}Path`;
+        const params = findRouteParams(routeDefinition);
+        params.push({
+          locale
+        });
+        if (!(routePathName in routes)) throw new Error(`${routePathName} not found in routes: ${Object.keys(routes, ", ")}`);
+        const routePath = routes[routePathName](...params).replace(/[/]+$/, "");
+        const groups = [];
+        let pathRegexString = "^";
+        pathRegexString += escapeStringRegexp(routePath);
+        while (true) {
+          const match = pathRegexString.match(regex);
+          if (!match) break;
+          const variableName = match[1];
+          groups.push(variableName);
+          pathRegexString = pathRegexString.replace(match[0], "([^/]+)");
+        }
+        pathRegexString += "$";
+        const pathRegex = new RegExp(pathRegexString);
+        parsedRouteDefinitions.push({
+          groups,
+          pathRegex,
+          routeDefinition
+        });
+      }
+    }
+    return parsedRouteDefinitions;
+  }, []);
+  const parsedRouteDefinitions = useMemo(() => parseRouteDefinitions(), []);
+  s.updateMeta({
+    parsedRouteDefinitions
+  });
+  const findMatchingRoute = useCallback(() => {
+    const path = getPath();
+    for (const parsedRouteDefinition of s.m.parsedRouteDefinitions) {
+      const match = path.match(parsedRouteDefinition.pathRegex);
+      let matched, params;
+      if (match) {
+        matched = true;
+        params = {};
+        for (const groupKey in parsedRouteDefinition.groups) {
+          const groupName = parsedRouteDefinition.groups[groupKey];
+          params[groupName] = match[Number(groupKey) + 1];
+        }
+      }
+      if (path == "" && parsedRouteDefinition.routeDefinition.path == "/") matched = true;
+      if (matched) {
+        return {
+          params,
+          parsedRouteDefinition
+        };
+      }
+    }
+  }, []);
+  const matchingRoute = findMatchingRoute();
+  const params = matchingRoute?.params || {};
+  const match = {
+    matchingRoute,
+    params
+  };
+  return {
+    match
+  };
+};
+useRouter.propTypes = {
+  path: PropTypes.string,
+  routeDefinitions: PropTypes.object,
+  routes: PropTypes.object
+};
+export default useRouter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["config","escapeStringRegexp","inflection","PropTypes","useCallback","useMemo","useShape","useRouter","props","s","findRouteParams","routeDefinition","result","parts","path","split","part","match","push","getPath","p","window","location","pathname","replace","getRouteDefinitions","routeDefinitions","getRoutes","routes","parseRouteDefinitions","Locales","require","default","regex","parsedRouteDefinitions","locale","availableLocales","routePathName","camelize","name","params","Error","Object","keys","routePath","groups","pathRegexString","variableName","pathRegex","RegExp","updateMeta","findMatchingRoute","parsedRouteDefinition","m","matched","groupKey","groupName","Number","matchingRoute","propTypes","string","object"],"sources":["../src/use-router.jsx"],"sourcesContent":["import config from \"./config\"\nimport escapeStringRegexp from \"escape-string-regexp\"\nimport * as inflection from \"inflection\"\nimport PropTypes from \"prop-types\"\nimport {useCallback, useMemo} from \"react\"\nimport useShape from \"set-state-compare/src/use-shape\"\n\nconst useRouter = (props) => {\n  const s = useShape(props)\n\n  const findRouteParams = useCallback((routeDefinition) => {\n    const result = []\n    const parts = routeDefinition.path.split(\"/\")\n\n    for (const part of parts) {\n      if (part.match(/^:([a-z_]+)$/))\n        result.push(part)\n    }\n\n    return result\n  }, [])\n\n  const getPath = useCallback(() => {\n    let path = s.p.path || window.location.pathname\n\n    path = path.replace(/[/]+$/, \"\")\n\n    return path\n  }, [])\n\n  const getRouteDefinitions = useCallback(() =>  s.p.routeDefinitions || config.getRouteDefinitions(), [])\n  const getRoutes = useCallback(() => s.p.routes || config.getRoutes(), [])\n\n  const parseRouteDefinitions = useCallback(() => {\n    const Locales = require(\"shared/locales\").default\n    const routeDefinitions = getRouteDefinitions()\n    const routes = getRoutes()\n    const regex = /:([A-z\\d_]+)/\n    const parsedRouteDefinitions = []\n\n    for (const locale of Locales.availableLocales()) {\n      for (const routeDefinition of routeDefinitions.routes) {\n        const routePathName = `${inflection.camelize(routeDefinition.name, true)}Path`\n        const params = findRouteParams(routeDefinition)\n\n        params.push({locale})\n\n        if (!(routePathName in routes))\n          throw new Error(`${routePathName} not found in routes: ${Object.keys(routes, \", \")}`)\n\n        const routePath = routes[routePathName](...params).replace(/[/]+$/, \"\")\n        const groups = []\n        let pathRegexString = \"^\"\n\n        pathRegexString += escapeStringRegexp(routePath)\n\n        while (true) {\n          const match = pathRegexString.match(regex)\n\n          if (!match) break\n\n          const variableName = match[1]\n\n          groups.push(variableName)\n\n          pathRegexString = pathRegexString.replace(match[0], \"([^/]+)\")\n        }\n\n        pathRegexString += \"$\"\n\n        const pathRegex = new RegExp(pathRegexString)\n\n        parsedRouteDefinitions.push({groups, pathRegex, routeDefinition})\n      }\n    }\n\n    return parsedRouteDefinitions\n  }, [])\n\n  const parsedRouteDefinitions = useMemo(() => parseRouteDefinitions(), [])\n\n  s.updateMeta({parsedRouteDefinitions})\n\n  const findMatchingRoute = useCallback(() => {\n    const path = getPath()\n\n    for (const parsedRouteDefinition of s.m.parsedRouteDefinitions) {\n      const match = path.match(parsedRouteDefinition.pathRegex)\n      let matched, params\n\n      if (match) {\n        matched = true\n        params = {}\n\n        for (const groupKey in parsedRouteDefinition.groups) {\n          const groupName = parsedRouteDefinition.groups[groupKey]\n\n          params[groupName] = match[Number(groupKey) + 1]\n        }\n      }\n\n      if (path == \"\" && parsedRouteDefinition.routeDefinition.path == \"/\") matched = true\n      if (matched) {\n        return {params, parsedRouteDefinition}\n      }\n    }\n  }, [])\n\n  const matchingRoute = findMatchingRoute()\n  const params = matchingRoute?.params || {}\n  const match = {\n    matchingRoute,\n    params\n  }\n\n  return {match}\n}\n\nuseRouter.propTypes = {\n  path: PropTypes.string,\n  routeDefinitions: PropTypes.object,\n  routes: PropTypes.object\n}\n\nexport default useRouter\n"],"mappings":"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","ignoreList":[]}

package/build/use-screen-layout.js

@@ -0,0 +1,39 @@
+import { Platform, useWindowDimensions } from "react-native";
+const getWindowLayout = width => {
+  if (width <= 575) {
+    return "xs";
+  } else if (width <= 767) {
+    return "sm";
+  } else if (width <= 991) {
+    return "md";
+  } else if (width <= 1199) {
+    return "lg";
+  } else if (width <= 1399) {
+    return "xl";
+  } else if (width >= 1400) {
+    return "xxl";
+  } else {
+    console.error(`Couldn't determine window layout from width: ${width}`);
+  }
+};
+const useScreenLayout = () => {
+  if (Platform.OS == "web") {
+    const shared = useMemo(() => ({}));
+    shared.width = window.innerWidth;
+    const [screenLayout, setScreenLayout] = useState(() => getWindowLayout(shared.width));
+    const onResize = useCallback(() => {
+      const newWindowLayout = getWindowLayout(window.innerWidth);
+      if (shared.screenlayout != newWindowLayout) {
+        setScreenLayout(newWindowLayout);
+      }
+    }, []);
+    useEventListener(window, "resize", onResize);
+    shared.screenLayout = screenLayout;
+    return shared.screenLayout;
+  } else {
+    const windowDimensions = useWindowDimensions();
+    return getWindowLayout(windowDimensions.width);
+  }
+};
+export default useScreenLayout;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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