@kaspernj/api-maker 1.0.2053 → 1.0.2054

package/src/params.js

@@ -1,66 +0,0 @@
-import config from "./config"
-import formSerialize from "form-serialize"
-import Incorporator from "incorporator"
-import qs from "qs"
-import urlEncode from "./url-encode"
-
-export default class Params {
-  static parse() {
-    return qs.parse(globalThis.location.search.substr(1))
-  }
-
-  static change(given) {
-    const incorporator = new Incorporator({objects: [Params.parse(), given]})
-
-    incorporator.replaceArrayIfExists(true)
-
-    return incorporator.merge()
-  }
-
-  static withParams(params) {
-    const newParams = qs.stringify(params, {encoder: urlEncode})
-    const newPath = `${location.pathname}?${newParams}`
-
-    return newPath
-  }
-
-  static changeParams(given, opts = {}) {
-    const params = Params.change(given)
-    const newParams = qs.stringify(params, {encoder: urlEncode})
-    const newPath = `${location.pathname}?${newParams}`
-    const appHistory = opts.appHistory || config.getHistory()
-
-    if (!appHistory) throw new Error("AppHistory hasn't been set in the ApiMaker configuration")
-
-    appHistory.push(newPath)
-  }
-
-  static serializeForm(form) {
-    const hash = formSerialize(form, {empty: true, hash: true})
-    return Params.setUndefined(hash)
-  }
-
-  // This is used to set all empty values to 'undefined' which makes qs removed those elements from the query string
-  static setUndefined(given) {
-    if (Array.isArray(given)) {
-      if (given.length == 0)
-        return undefined
-
-      return given.map((givenI) => Params.setUndefined(givenI))
-    } else if (typeof given === "object") {
-      if (Object.keys(given).length == 0)
-        return undefined
-
-      const newGiven = {}
-      for (const key in given) {
-        newGiven[key] = Params.setUndefined(given[key])
-      }
-
-      return newGiven
-    } else if (given === "") {
-      return undefined
-    } else {
-      return given
-    }
-  }
-}

package/src/preloaded.js

@@ -1,43 +0,0 @@
-import * as inflection from "inflection"
-import modelClassRequire from "./model-class-require"
-
-export default class ApiMakerPreloaded {
-  constructor (response) {
-    this.response = response
-    this.loadPreloadedModels()
-  }
-
-  loadPreloadedModels () {
-    this.preloaded = {}
-
-    for (const preloadedType in this.response.preloaded) {
-      const modelClassName = inflection.classify(preloadedType)
-      const ModelClass = modelClassRequire(modelClassName)
-
-      for (const preloadedId in this.response.preloaded[preloadedType]) {
-        const preloadedData = this.response.preloaded[preloadedType][preloadedId]
-        const model = new ModelClass({data: preloadedData, isNewRecord: false})
-
-        if (!this.preloaded[preloadedType]) {
-          this.preloaded[preloadedType] = {}
-        }
-
-        this.preloaded[preloadedType][preloadedId] = model
-      }
-    }
-
-    for (const modelType in this.preloaded) {
-      for (const modelId in this.preloaded[modelType]) {
-        this.preloaded[modelType][modelId]._readPreloadedRelationships(this)
-      }
-    }
-  }
-
-  getModel (type, id) {
-    if (!this.preloaded[type] || !this.preloaded[type][id]) {
-      throw new Error(`Could not find a ${type} by that ID: ${id}`)
-    }
-
-    return this.preloaded[type][id]
-  }
-}

package/src/resize-observer.jsx

@@ -1,10 +0,0 @@
-import memo from "set-state-compare/src/memo"
-import useResizeObserver from "./use-resize-observer"
-
-const ApiMakerResizeObserver = memo(({element, onResize}) => {
-  useResizeObserver(element, onResize)
-
-  return null
-})
-
-export default ApiMakerResizeObserver

package/src/rest-props-validator.js

@@ -1,9 +0,0 @@
-const restPropsValidator = (restProps) => {
-  const restPropsKeys = Object.keys(restProps)
-
-  if (restPropsKeys.length > 0) {
-    throw new Error(`Invalid props: ${restPropsKeys.join(", ")}`)
-  }
-}
-
-export default restPropsValidator

package/src/result.js

@@ -1,13 +0,0 @@
-export default class ApiMakerResult {
-  constructor (data) {
-    this.data = data
-  }
-
-  count = () => this.data.response.meta.count
-  currentPage = () => this.data.response.meta.currentPage
-  models = () => this.data.models
-  modelClass = () => this.data.collection.modelClass()
-  perPage = () => this.data.response.meta.perPage
-  totalCount = () => this.data.response.meta.totalCount
-  totalPages = () => this.data.response.meta.totalPages
-}

package/src/router/route.jsx

@@ -1,246 +0,0 @@
-import BaseComponent from "../base-component"
-import React, {createContext, useContext, useMemo} from "react"
-import memo from "set-state-compare/src/memo"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import {shapeComponent} from "set-state-compare/src/shape-component"
-import Switch, {CurrentSwitchContext} from "./switch"
-import useI18n from "i18n-on-steroids/src/use-i18n"
-
-const CurrentPathContext = createContext([])
-const ParamsContext = createContext({})
-const RequireComponentContext = createContext(null)
-const RouteContext = createContext(null)
-const useParams = () => useContext(ParamsContext)
-
-const Route = memo(shapeComponent(class Route extends BaseComponent {
-  static defaultProps = {
-    exact: false,
-    fallback: false,
-    includeInPath: true
-  }
-
-  static propTypes = propTypesExact({
-    children: PropTypes.any,
-    component: PropTypes.string,
-    componentPath: PropTypes.string,
-    exact: PropTypes.bool.isRequired,
-    fallback: PropTypes.bool.isRequired,
-    includeInPath: PropTypes.bool.isRequired,
-    onMatch: PropTypes.func,
-    path: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(RegExp)])
-  })
-
-  match = null
-  newParams = null
-  pathParts = null
-
-  setup() {
-    const {t} = useI18n({namespace: "js.api_maker.router.route"})
-    const {path} = this.props
-    const {pathsMatched, switchGroup} = useContext(CurrentSwitchContext)
-    const givenRoute = useContext(RouteContext)
-    const {pathShown} = switchGroup.s
-
-    this.debug = false
-    this.log(() => ({givenRoute}))
-    this.t = t
-
-    this.requireComponent = useContext(RequireComponentContext)
-    this.currentParams = useContext(ParamsContext)
-    this.currentPath = useContext(CurrentPathContext)
-    this.switchGroup = switchGroup
-    this.routeParts = useMemo(() => givenRoute?.split("/"), [path, givenRoute])
-    this.pathParts = useMemo(() => path?.split("/"), [path])
-
-    this.newRouteParts = useMemo(
-      () => {
-        if (!path) {
-          if (givenRoute == "") {
-            return []
-          } else {
-            return this.routeParts
-          }
-        }
-
-        return this.routeParts.slice(this.pathParts.length, this.routeParts.length)
-      },
-      [givenRoute].concat(this.pathParts)
-    )
-
-    this.useStates({Component: null, componentNotFound: null, matches: false})
-
-    useMemo(() => {
-      this.loadMatches()
-    }, [givenRoute, path, pathsMatched])
-
-    useMemo(() => {
-      if (this.hasSwitchMatch() && !this.s.Component && this.s.matches) {
-        if (this.props.onMatch) {
-          this.props.onMatch()
-        }
-
-        if (!this.props.children && (this.props.path || this.props.component || this.props.componentPath)) {
-          this.loadComponent()
-        }
-      }
-    }, [path, pathShown, this.s.matches])
-  }
-
-  hasSwitchMatch = () => this.switchGroup.s.pathShown && this.switchGroup.s.pathShown == this.pathId()
-
-  pathId() {
-    const {fallback} = this.p
-    const {path} = this.props
-    let pathId
-
-    if (fallback) {
-      pathId = "[FALLBACK]"
-    } else if (!path) {
-      pathId = "[PATH-EMPTY]"
-    } else {
-      pathId = path
-    }
-
-    return pathId
-  }
-
-  loadMatches() {
-    const {newRouteParts, t} = this.tt
-    const {component, path} = this.props
-    const {exact, includeInPath, fallback} = this.p
-
-    let matches = true
-    const params = {}
-    const componentPathParts = [...this.currentPath]
-
-    this.log(() => [this.props.path, "Start generating component paths", JSON.stringify(componentPathParts)])
-
-    for (const pathPartIndex in this.pathParts) {
-      const pathPart = this.pathParts[pathPartIndex]
-      const translatedPathPart = t(`routes.${pathPart}`, {defaultValue: pathPart})
-
-      if (!(pathPartIndex in this.routeParts)) {
-        this.log(() => `No match for: ${pathPartIndex}`)
-        matches = false
-        break
-      }
-
-      const routePart = decodeURIComponent(this.routeParts[pathPartIndex])
-
-      if (pathPart.startsWith(":") && routePart) {
-        const paramName = pathPart.slice(1, pathPart.length)
-
-        params[paramName] = routePart
-      } else if (translatedPathPart != routePart) {
-        matches = false
-        break
-      } else if (!component && includeInPath) {
-        componentPathParts.push(pathPart)
-      }
-    }
-
-    if (exact && newRouteParts.length > 0) {
-      this.log(() => ["Exact and more route parts", {newRouteParts, pathParts: this.pathParts, routeParts: this.routeParts}])
-      matches = false
-    } else if (matches && path) {
-      matches = true
-    } else if (this.routeParts.length == 0) {
-      matches = true
-    }
-
-    const matchId = this.pathId()
-
-    if (!matches && fallback) {
-      matches = true
-    }
-
-    this.log(() => [this.props.path, "End generating component paths", JSON.stringify(componentPathParts), {matches}])
-
-    if (matches) {
-      if (component && includeInPath) {
-        componentPathParts.push(component)
-      }
-
-      const newParams = Object.assign({}, this.currentParams, params)
-
-      this.setInstance({componentPathParts, match: {params}, newParams})
-      this.setState({matches})
-      this.switchGroup?.setPathMatched(matchId, true)
-    } else {
-      this.setInstance({componentPathParts: null, match: null, newParams: null})
-      this.setState({matches})
-      this.switchGroup?.setPathMatched(matchId, false)
-    }
-  }
-
-  async loadComponent() {
-    const actualComponentPath = this.props.componentPath || this.tt.componentPathParts.join("/")
-    let Component
-
-    this.log(() => ["loadComponent", {componentPath: this.props.componentPath, componentPathParts: this.componentPathParts, actualComponentPath}])
-
-    try {
-      const componentImport = await this.tt.requireComponent({routeDefinition: {component: actualComponentPath}})
-
-      Component = componentImport
-    } catch (error) {
-      console.error(`Couldn't find component: ${actualComponentPath}`)
-
-      throw error
-    }
-
-    this.setState({Component, componentNotFound: !Component})
-  }
-
-  log(callbackArgs) {
-    if (this.debug) {
-      let args = callbackArgs()
-
-      if (!Array.isArray(args)) args = [args]
-
-      console.log(...args)
-    }
-  }
-
-  render() {
-    const {componentPathParts, match, newParams, newRouteParts} = this.tt
-    const {children, component, path} = this.props
-    const {Component, componentNotFound, matches} = this.s
-
-    if (!matches || !this.hasSwitchMatch()) {
-      // Route isn't matching and shouldn't be rendered at all.
-      return null
-    }
-
-    if (!Component && !children && !componentNotFound) {
-      // Route is matching but hasn't been loaded yet.
-      return (
-        <div>
-          Loading {component || this.props.componentPath || componentPathParts.join("/")}
-        </div>
-      )
-    }
-
-    if (!Component && !children && componentNotFound) {
-      // Don't render anything if the component couldn't be found.
-      return null
-    }
-
-    return (
-      <CurrentPathContext.Provider value={componentPathParts}>
-        <RouteContext.Provider value={newRouteParts.join("/")}>
-          <ParamsContext.Provider value={newParams}>
-            <Switch name={`route-group-${path}`} single={false}>
-              {Component && <Component match={match} />}
-              {children}
-            </Switch>
-          </ParamsContext.Provider>
-        </RouteContext.Provider>
-      </CurrentPathContext.Provider>
-    )
-  }
-}))
-
-export {RequireComponentContext, RouteContext, Switch, useParams}
-export default Route

package/src/router/switch.jsx

@@ -1,76 +0,0 @@
-import BaseComponent from "../base-component"
-import React, {createContext} from "react"
-import memo from "set-state-compare/src/memo"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import {shapeComponent} from "set-state-compare/src/shape-component"
-
-const CurrentSwitchContext = createContext([])
-
-const Switch = memo(shapeComponent(class Switch extends BaseComponent {
-  static defaultProps = {
-    name: "[no name]",
-    single: true
-  }
-
-  static propTypes = propTypesExact({
-    children: PropTypes.any,
-    name: PropTypes.string,
-    single: PropTypes.bool
-  })
-
-  pathsMatchedKeys = []
-
-  setup() {
-    this.useStates({
-      lastUpdate: new Date(),
-      pathShown: undefined,
-      pathsMatched: {}
-    })
-  }
-
-  render() {
-    const {pathShown, pathsMatched} = this.s
-
-    return (
-      <CurrentSwitchContext.Provider value={{pathShown, pathsMatched, switchGroup: this}}>
-        {this.props.children}
-      </CurrentSwitchContext.Provider>
-    )
-  }
-
-  pathShown(pathsMatched) {
-    for (const pathMatched of this.tt.pathsMatchedKeys) {
-      const isPathMatched = pathsMatched[pathMatched]
-
-      if (isPathMatched) {
-        return pathMatched
-      }
-    }
-  }
-
-  setPathMatched(path, matched) {
-    const {pathsMatchedKeys} = this.tt
-    const {pathsMatched} = this.s
-
-    if (!path) throw new Error("No 'path' given")
-    if (pathsMatched[path] == matched) return
-
-    if (!pathsMatchedKeys.includes(path)) {
-      pathsMatchedKeys.push(path)
-    }
-
-    const newPathsMatched = {...this.s.pathsMatched}
-
-    newPathsMatched[path] = matched
-
-    this.setState({
-      lastUpdate: Math.random() + new Date().getTime(),
-      pathShown: this.pathShown(newPathsMatched),
-      pathsMatched: newPathsMatched
-    })
-  }
-}))
-
-export {CurrentSwitchContext}
-export default Switch

package/src/router.jsx

@@ -1,47 +0,0 @@
-import BaseComponent from "./base-component"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import React, {memo, Suspense} from "react"
-import {shapeComponent} from "set-state-compare/src/shape-component"
-import usePath from "on-location-changed/build/use-path"
-import useRouter from "./use-router"
-
-export default memo(shapeComponent(class ApiMakerRouter extends BaseComponent {
-  static propTypes = propTypesExact({
-    history: PropTypes.object,
-    locales: PropTypes.array.isRequired,
-    notFoundComponent: PropTypes.elementType,
-    requireComponent: PropTypes.func.isRequired,
-    routeDefinitions: PropTypes.object,
-    routes: PropTypes.object
-  })
-
-  render() {
-    const path = usePath()
-    const {locales, notFoundComponent, requireComponent, routeDefinitions, routes} = this.props
-    const {match} = useRouter({locales, path, routes, routeDefinitions})
-    const {matchingRoute} = match
-
-    if (!matchingRoute) {
-      if (notFoundComponent) {
-        const NotFoundComponent = notFoundComponent
-
-        return (
-          <Suspense fallback={<div />}>
-            <NotFoundComponent match={match} />
-          </Suspense>
-        )
-      } else {
-        return null
-      }
-    }
-
-    const Component = requireComponent({routeDefinition: matchingRoute.parsedRouteDefinition.routeDefinition})
-
-    return (
-      <Suspense fallback={<div />}>
-        <Component match={match} />
-      </Suspense>
-    )
-  }
-}))

package/src/routes-native.js

@@ -1,173 +0,0 @@
-import {dig, digg, digs} from "diggerize"
-import * as inflection from "inflection"
-import qs from "qs"
-import urlEncode from "./url-encode"
-
-export default class ApiMakerRoutesNative {
-  constructor ({getLocale}) {
-    this.getLocale = getLocale
-    this.routeDefinitions = []
-    this.routeTranslationParts = {}
-  }
-
-  loadRouteDefinitions (routeDefinitions, routeDefinitionArgs) {
-    for (const routeDefinition of digg(routeDefinitions, "routes")) {
-      const {name, path} = digs(routeDefinition, "name", "path")
-      const rawPathParts = path.split("/")
-      const pathMethodName = `${inflection.camelize(name, true)}Path`
-      const urlMethodName = `${inflection.camelize(name, true)}Url`
-
-      if (routeDefinitionArgs && routeDefinitionArgs.localized) {
-        const localizedRoutes = {}
-
-        for (const locale in this.routeTranslationParts) {
-          let variableCount = 0
-
-          const localizedPathParts = [
-            {type: "pathPart", name: ""},
-            {type: "pathPart", name: locale}
-          ]
-
-          for (let i = 1; i < rawPathParts.length; i++) {
-            const pathPart = rawPathParts[i]
-            const variableMatch = pathPart.match(/^:([A-z_]+)$/)
-
-            if (variableMatch) {
-              localizedPathParts.push({type: "variable", count: variableCount++})
-            } else if (pathPart) {
-              const name = this.i18n.t(`routes.${pathPart}`, null, {default: pathPart, locale})
-
-              localizedPathParts.push({type: "pathPart", name})
-            }
-          }
-
-          localizedRoutes[locale] = localizedPathParts
-        }
-
-        this[pathMethodName] = (...args) => this.translateRoute({args, localizedRoutes})
-        this[urlMethodName] = (...args) => this.translateRoute({args, localizedRoutes, url: true})
-      } else {
-        let variableCount = 0
-
-        const pathParts = rawPathParts.map((pathPart) => {
-          const variableMatch = pathPart.match(/^:([A-z_]+)$/)
-
-          if (variableMatch) {
-            return {type: "variable", count: variableCount}
-          } else {
-            return {type: "pathPart", name: pathPart}
-          }
-        })
-
-        this[pathMethodName] = (...args) => this.translateRoute({args, pathParts})
-        this[urlMethodName] = (...args) => this.translateRoute({args, pathParts, url: true})
-      }
-    }
-  }
-
-  loadRouteTranslations (i18n) {
-    this.i18n = i18n
-    const locales = digg(i18n, "locales")
-
-    for (const locale in locales) {
-      const routeTranslations = dig(locales, locale, "routes")
-
-      if (!routeTranslations) continue
-      if (!(locale in this.routeTranslationParts)) this.routeTranslationParts[locale] = {}
-
-      for (const key in routeTranslations) {
-        this.routeTranslationParts[locale][key] = routeTranslations[key]
-      }
-    }
-  }
-
-  translateRoute ({args, localizedRoutes, pathParts, url}) {
-    let options
-
-    // Extract options from args if any
-    const lastArg = args[args.length - 1]
-
-    if (lastArg && typeof lastArg == "object") {
-      options = args.pop()
-    } else {
-      options = {}
-    }
-
-    // Take locale from options if given or fall back to fallback
-    const {locale, host, port, protocol, ...restOptions} = options
-
-    if (localizedRoutes) {
-      // Put together route with variables and static translated parts (which were translated and cached previously)
-      let translatedRoute = digg(localizedRoutes, locale || this.getLocale())
-        .map((pathPart) => {
-          if (pathPart.type == "pathPart") {
-            return pathPart.name
-          } else if (pathPart.type == "variable") {
-            // Args might not contain the right amount of variables, so dont change this to 'digg'
-            return dig(args, digg(pathPart, "count"))
-          } else {
-            throw new Error(`Unhandled path part type: ${pathPart.type}`)
-          }
-        })
-        .join("/")
-
-      if (restOptions && Object.keys(restOptions).length > 0) {
-        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`
-      }
-
-      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})
-
-      return translatedRoute
-    } else if (pathParts) {
-      // Put together route with variables and static translated parts (which were translated and cached previously)
-      let translatedRoute = pathParts
-        .map((pathPart) => {
-          if (pathPart.type == "pathPart") {
-            return pathPart.name
-          } else if (pathPart.type == "variable") {
-            return digg(args, digg(pathPart, "count"))
-          } else {
-            throw new Error(`Unhandled path part type: ${pathPart.type}`)
-          }
-        })
-        .join("/")
-
-      if (restOptions && Object.keys(restOptions).length > 0) {
-        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`
-      }
-
-      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})
-
-      return translatedRoute
-    }
-
-    throw new Error("Unhandled state")
-  }
-
-  addHostToRoute ({host, port, protocol, translatedRoute}) {
-    let fullUrl = ""
-
-    const hostToUse = host || globalThis.location && globalThis.location.host
-    const portToUse = port || globalThis.location && globalThis.location.port
-
-    if (!hostToUse) throw new Error("Unable to detect host")
-
-    if (protocol) {
-      fullUrl += `${protocol}://`
-    } else if (globalThis.location && globalThis.location.protocol) {
-      fullUrl += `${globalThis.location.protocol}//`
-    } else {
-      fullUrl += "https://"
-    }
-
-    fullUrl += hostToUse
-
-    if (portToUse && ((protocol == "http" && portToUse != 80) || (protocol == "https" && port != 443))) {
-      fullUrl += `:${portToUse}`
-    }
-
-    fullUrl += translatedRoute
-
-    return fullUrl
-  }
-}