@kaspernj/api-maker 1.0.335 → 1.0.337

package/package.json

@@ -16,7 +16,7 @@
     ]
   },
   "name": "@kaspernj/api-maker",
-  "version": "1.0.335",
+  "version": "1.0.337",
   "type": "module",
   "description": "",
   "main": "index.js",

package/src/api.mjs

@@ -4,23 +4,23 @@ import FormDataObjectizer from "form-data-objectizer"
 import qs from "qs"
 
 export default class Api {
-  static get (path, pathParams = null) {
+  static get(path, pathParams = null) {
     return Api.requestLocal({path, pathParams, method: "GET"})
   }
 
-  static delete (path, pathParams = null) {
+  static delete(path, pathParams = null) {
     return Api.requestLocal({path, pathParams, method: "DELETE"})
   }
 
-  static patch (path, data = {}) {
+  static patch(path, data = {}) {
     return Api.requestLocal({path, data, method: "PATCH"})
   }
 
-  static post (path, data = {}) {
+  static post(path, data = {}) {
     return Api.requestLocal({path, data, method: "POST"})
   }
 
-  static request ({data, headers, method, path, pathParams}) {
+  static request({data, headers, method, path, pathParams}) {
     let requestPath = ""
     if (config.getHost()) requestPath += config.getHost()
     requestPath += path
@@ -62,7 +62,7 @@ export default class Api {
     })
   }
 
-  static requestLocal (args) {
+  static requestLocal(args) {
     if (!args.headers) {
       args.headers = {}
     }
@@ -85,18 +85,18 @@ export default class Api {
     return this.request(args)
   }
 
-  static put (path, data = {}) {
+  static put(path, data = {}) {
     return this.requestLocal({path, data, method: "PUT"})
   }
 
-  static _token () {
+  static _token() {
     const tokenElement = document.querySelector("meta[name='csrf-token']")
 
     if (tokenElement)
       return tokenElement.getAttribute("content")
   }
 
-  static _parseResponse (xhr) {
+  static _parseResponse(xhr) {
     const responseType = xhr.getResponseHeader("content-type")
 
     if (responseType && responseType.startsWith("application/json")) {

package/src/commands-pool.mjs

@@ -4,6 +4,7 @@ import CustomError from "./custom-error.mjs"
 import DestroyError from "./destroy-error.mjs"
 import Deserializer from "./deserializer.mjs"
 import {dig, digg} from "diggerize"
+import events from "./events.mjs"
 import FormDataObjectizer from "form-data-objectizer"
 import Serializer from "./serializer.mjs"
 import SessionStatusUpdater from "./session-status-updater.mjs"
@@ -176,6 +177,8 @@ export default class ApiMakerCommandsPool {
         validationErrors: digg(commandResponseData, "validation_errors")
       })
       error = new ValidationError(validationErrors, {response: commandResponseData})
+
+      events.emit("onValidationErrors", validationErrors)
     } else {
       let errorMessage
 

package/src/devise.mjs

@@ -1,18 +1,13 @@
 import CanCan from "./can-can.mjs"
 import Deserializer from "./deserializer.mjs"
 import {digg} from "diggerize"
-import EventEmitter from "events"
+import events from "./events.mjs"
 import * as inflection from "inflection"
 import modelClassRequire from "./model-class-require.mjs"
 import Services from "./services.mjs"
 
-const events = new EventEmitter()
 const shared = {}
 
-events.setMaxListeners(1000)
-
-export {events}
-
 export default class ApiMakerDevise {
   static callSignOutEvent (args) {
     events.emit("onDeviseSignOut", {args})

package/src/event-listener.jsx

@@ -1,36 +1,25 @@
 import PropTypes from "prop-types"
 import propTypesExact from "prop-types-exact"
-import React from "react"
+import {memo} from "react"
+import useEventListener from "./use-event-listener.mjs"
 
-export default class ApiMakerEventListener extends React.PureComponent {
-  static callEvent (target, eventName, args = []) {
-    let event = document.createEvent("Event")
-    event.initEvent(eventName, false, true)
-    target.dispatchEvent(event, args)
-  }
-
-  static propTypes = propTypesExact({
-    event: PropTypes.string.isRequired,
-    onCalled: PropTypes.func.isRequired,
-    target: PropTypes.object.isRequired
-  })
-
-  constructor (props) {
-    super(props)
-    this.onCalled = this.onCalled.bind(this)
-  }
+const callEvent = (target, eventName, args = []) => {
+  let event = document.createEvent("Event")
+  event.initEvent(eventName, false, true)
+  target.dispatchEvent(event, args)
+}
 
-  componentDidMount () {
-    this.props.target.addEventListener(this.props.event, this.onCalled)
-  }
+const ApiMakerEventListener = ({event, onCalled, target}) => {
+  useEventListener(target, event, onCalled)
 
-  componentWillUnmount () {
-    this.props.target.removeEventListener(this.props.event, this.onCalled)
-  }
+  return null
+}
 
-  onCalled (...args) {
-    this.props.onCalled.apply(null, args)
-  }
+ApiMakerEventListener.propTypes = propTypesExact({
+  event: PropTypes.string.isRequired,
+  onCalled: PropTypes.func.isRequired,
+  target: PropTypes.object.isRequired
+})
 
-  render = () => null
-}
+export {callEvent}
+export default memo(ApiMakerEventListener)

package/src/events.mjs

@@ -0,0 +1,7 @@
+import EventEmitter from "events"
+
+const events = new EventEmitter()
+
+events.setMaxListeners(1000)
+
+export default events

package/src/inputs/input-wrapper.jsx

@@ -140,9 +140,7 @@ const inputWrapper = (WrapperComponentClass, wrapperOptions = {}) => {
       return this._inputRefBackup
     }
 
-    inputRef() {
-      return this.props.inputRef || this.inputRefBackup()
-    }
+    inputRef = () => this.props.inputRef || this.inputRefBackup()
 
     inputType() {
       if ("type" in this.props) {

package/src/use-current-user.mjs

@@ -33,16 +33,23 @@ const useCurrentUser = (args) => {
 
     if (!(scopeName in s.setStates)) throw new Error(`'${scopeName}' not found in setStates`)
 
+    Devise.updateSession(current)
     s.setStates[scopeName](current)
+
+    if (s.props.onCurrentUserLoaded) setTimeout(() => s.props.onCurrentUserLoaded(current), 0)
   }, [])
 
   const defaultCurrentUser = useCallback(() => {
     const {scope, scopeName} = s.m
 
     if (Devise.current().hasCurrentScope(scope)) {
-      debugs(() => `Setting ${scope} from current scope`)
+      const current = Devise[scopeName]()
+
+      debugs(() => `Setting ${scope} from current scope: ${current?.id()}`)
+
+      if (s.props.onCurrentUserLoaded) setTimeout(() => s.props.onCurrentUserLoaded(current), 0)
 
-      return Devise[scopeName]()
+      return current
     }
   }, [])
 

package/src/use-event-emitter.mjs

@@ -1,10 +1,8 @@
-import EventEmitter from "events"
-import PropTypes from "prop-types"
 import {useCallback, useEffect} from "react"
 
 const ApiMakerUseEventEmitter = (events, event, onCalled) => {
   const onCalledCallback = useCallback((...args) => {
-    onCalled.apply(null, ...args)
+    onCalled.apply(null, args)
   }, [events, event, onCalled])
 
   useEffect(() => {
@@ -16,10 +14,4 @@ const ApiMakerUseEventEmitter = (events, event, onCalled) => {
   }, [events, event, onCalled])
 }
 
-ApiMakerUseEventEmitter.propTypes = {
-  event: PropTypes.string.isRequired,
-  events: PropTypes.instanceOf(EventEmitter).isRequired,
-  onCalled: PropTypes.func.isRequired
-}
-
 export default ApiMakerUseEventEmitter

package/src/use-event-listener.mjs

@@ -0,0 +1,17 @@
+import {useCallback, useEffect} from "react"
+
+const ApiMakerUseEventListener = (target, event, onCalled) => {
+  const onCalledCallback = useCallback((...args) => {
+    onCalled.apply(null, args)
+  }, [target, event, onCalled])
+
+  useEffect(() => {
+    target.addEventListener(event, onCalledCallback)
+
+    return () => {
+      target.removeEventListener(event, onCalledCallback)
+    }
+  }, [target, event, onCalled])
+}
+
+export default ApiMakerUseEventListener

package/src/use-validation-errors.mjs

@@ -0,0 +1,32 @@
+import events from "./events.mjs"
+import useEventEmitter from "./use-event-emitter.mjs"
+import useShape from "set-state-compare/src/use-shape.js"
+
+const useValidationErrors = (callback) => {
+  const s = useShape({callback})
+
+  s.useStates({validationErrors: []})
+
+  const onValidationErrors = useCallback((validationErrors) => {
+    const matchedValidationErrors = []
+
+    for (const validationError of validationErrors.getValidationErrors()) {
+      if (s.p.callback(validationError)) {
+        validationError.setHandled()
+        matchedValidationErrors.push(validationError)
+      }
+    }
+
+    s.set({
+      validationErrors: matchedValidationErrors
+    })
+  }, [])
+
+  useEventEmitter(events, "onValidationErrors", onValidationErrors)
+
+  return {
+    validationErrors: s.s.validationErrors
+  }
+}
+
+export default useValidationErrors

package/src/validation-error.mjs

@@ -2,7 +2,7 @@ import BaseError from "./base-error.mjs"
 import * as inflection from "inflection"
 
 class ValidationError extends BaseError {
-  constructor (validationErrors, args) {
+  constructor(validationErrors, args) {
     const errorMessage = validationErrors.getUnhandledErrorMessage() || validationErrors.getErrorMessage()
     const forwardedArgs = {addResponseErrorsToErrorMessage: false}
     const newArgs = Object.assign({}, args, forwardedArgs)
@@ -11,12 +11,13 @@ class ValidationError extends BaseError {
     this.validationErrors = validationErrors
   }
 
-  hasUnhandledErrors () {
+  hasUnhandledErrors() {
     const unhandledError = this.validationErrors.getValidationErrors().find((validationError) => !validationError.getHandled())
+
     return Boolean(unhandledError)
   }
 
-  hasValidationErrorForAttribute (attributeName) {
+  hasValidationErrorForAttribute(attributeName) {
     const underscoredAttributeName = inflection.underscore(attributeName)
     const foundAttribute = this.validationErrors.getValidationErrors().find((validationError) => validationError.getAttributeName() == underscoredAttributeName)
 

package/src/validation-errors.mjs

@@ -30,13 +30,8 @@ class ValidationError {
     return false
   }
 
-  getAttributeName() {
-    return digg(this, "attributeName")
-  }
-
-  getErrorMessages() {
-    return digg(this, "errorMessages")
-  }
+  getAttributeName = () => digg(this, "attributeName")
+  getErrorMessages = () => digg(this, "errorMessages")
 
   getFullErrorMessages() {
     const {attributeType} = digs(this, "attributeType")
@@ -55,13 +50,8 @@ class ValidationError {
     }
   }
 
-  getHandled() {
-    return digg(this, "handled")
-  }
-
-  getInputName() {
-    return digg(this, "inputName")
-  }
+  getHandled = () => digg(this, "handled")
+  getInputName = () => digg(this, "inputName")
 
   getModelClass() {
     const modelName = inflection.classify(digg(this, "modelName"))
@@ -92,9 +82,7 @@ class ValidationErrors {
     return fullErrorMessages.join(". ")
   }
 
-  getValidationErrors() {
-    return this.validationErrors
-  }
+  getValidationErrors = () => this.validationErrors
 
   getValidationErrorsForInput ({attribute, inputName, onMatchValidationError}) {
     const validationErrors = this.validationErrors.filter((validationError) => {