@kaspernj/api-maker 1.0.2053 → 1.0.2054

package/src/config.js

@@ -1,71 +0,0 @@
-import EventEmitter from "events"
-import * as inflection from "inflection"
-
-const accessors = {
-  breakpoints: {
-    default: [
-      ["xxl", 1400],
-      ["xl", 1200],
-      ["lg", 992],
-      ["md", 768],
-      ["sm", 576],
-      ["xs", 0]
-    ],
-    required: true
-  },
-  cableUrl: {require: false},
-  currenciesCollection: {required: true},
-  history: {required: true},
-  host: {required: false},
-  i18n: {required: false},
-  linkTo: {required: true},
-  modal: {required: false},
-  navigation: {required: true},
-  routes: {required: false},
-  routeDefinitions: {required: false}
-}
-
-class ApiMakerConfig {
-  constructor() {
-    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {}
-
-    this.global = globalThis.apiMakerConfigGlobal
-
-    this.events = new EventEmitter()
-    this.events.setMaxListeners(Infinity)
-  }
-
-  getEvents = () => this.events
-}
-
-for (const accessorName in accessors) {
-  const accessorData = accessors[accessorName]
-  const camelizedAccessor = inflection.camelize(accessorName)
-
-  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {
-    const oldValue = this.global[accessorName]
-
-    this.global[accessorName] = newValue
-
-    if (oldValue !== newValue) {
-      this.events.emit(`on${camelizedAccessor}Change`, {oldValue, newValue})
-    }
-  }
-
-  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {
-    if (!this.global[accessorName]) {
-      if (accessorData.default) return accessorData.default
-      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`)
-    }
-
-    const value = this.global[accessorName]
-
-    if (typeof value == "function") return value(...args)
-
-    return value
-  }
-}
-
-const apiMakerConfig = new ApiMakerConfig()
-
-export default apiMakerConfig

package/src/custom-error.js

@@ -1,7 +0,0 @@
-import BaseError from "./base-error"
-
-class CustomError extends BaseError {}
-
-CustomError.apiMakerType = "CustomError"
-
-export default CustomError

package/src/data-set-to-attributes.js

@@ -1,13 +0,0 @@
-import * as inflection from "inflection"
-
-export default function dataSetToAttributes(dataSet) {
-  const result = {}
-
-  for (const key in dataSet) {
-    const dasherizedKey = `data-${inflection.dasherize(inflection.underscore(key))}`
-
-    result[dasherizedKey] = dataSet[key]
-  }
-
-  return result
-}

package/src/deserializer.js

@@ -1,60 +0,0 @@
-import {digg} from "diggerize"
-import * as inflection from "inflection"
-import modelClassRequire from "./model-class-require"
-import ModelsResponseReader from "./models-response-reader"
-import Money from "js-money"
-
-export default class ApiMakerDeserializer {
-  static parse (object) {
-    if (Array.isArray(object)) {
-      return object.map((value) => ApiMakerDeserializer.parse(value))
-    } else if (object && typeof object == "object") {
-      if (object.api_maker_type == "date") {
-        const date = new Date(digg(object, "value"))
-
-        date.apiMakerType = "date"
-
-        return date
-      } else if (object.api_maker_type == "time") {
-        const date = new Date(digg(object, "value"))
-
-        date.apiMakerType = "time"
-
-        return date
-      } else if (object.api_maker_type == "collection") {
-        // Need to remove type to avoid circular error
-        const {api_maker_type, ...restObject} = object
-
-        return ModelsResponseReader.collection(ApiMakerDeserializer.parse(restObject))
-      } else if (object.api_maker_type == "money") {
-        const cents = digg(object, "amount")
-        const currency = digg(object, "currency")
-
-        return Money.fromInteger(cents, currency)
-      } else if (object.api_maker_type == "model") {
-        const modelClassName = inflection.classify(digg(object, "model_name"))
-        const ModelClass = modelClassRequire(modelClassName)
-        const data = ApiMakerDeserializer.parse(digg(object, "serialized"))
-        const model = new ModelClass({data, isNewRecord: false})
-
-        return model
-      } else if (object.api_maker_type == "resource") {
-        const modelClassName = inflection.classify(digg(object, "name"))
-        const ModelClass = modelClassRequire(modelClassName)
-
-        return ModelClass
-      } else {
-        const newObject = {}
-
-        for (const key in object) {
-          const value = object[key]
-          newObject[key] = ApiMakerDeserializer.parse(value)
-        }
-
-        return newObject
-      }
-    } else {
-      return object
-    }
-  }
-}

package/src/destroy-error.js

@@ -1,7 +0,0 @@
-import CustomError from "./custom-error"
-
-class DestroyError extends CustomError {}
-
-DestroyError.apiMakerType = "DestroyError"
-
-export default DestroyError

package/src/devise.js

@@ -1,151 +0,0 @@
-import {createContext} from "react"
-import Deserializer from "./deserializer"
-import events from "./events"
-import * as inflection from "inflection"
-import modelClassRequire from "./model-class-require"
-import Services from "./services"
-
-if (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {scopes: {}}
-
-const shared = globalThis.ApiMakerDevise
-
-class DeviseScope {
-  constructor(scope, args) {
-    this.args = args
-    this.context = createContext()
-    this.scope = scope
-  }
-
-  getContext = () => this.context
-}
-
-export default class ApiMakerDevise {
-  static callSignOutEvent(args) {
-    events.emit("onDeviseSignOut", {args})
-  }
-
-  static current() {
-    if (!shared.currentApiMakerDevise) {
-      shared.currentApiMakerDevise = new ApiMakerDevise()
-    }
-
-    return shared.currentApiMakerDevise
-  }
-
-  static events() {
-    return events
-  }
-
-  static addUserScope(scope, args = {}) {
-    const scopeCamelized = inflection.camelize(scope)
-    const currentMethodName = `current${scopeCamelized}`
-    const isSignedInMethodName = `is${scopeCamelized}SignedIn`
-    const getArgsMethodName = `get${scopeCamelized}Args`
-    const getScopeName = `get${scopeCamelized}Scope`
-    const scopeInstance = new DeviseScope(scope, args)
-
-    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope)
-    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope))
-    ApiMakerDevise[getArgsMethodName] = () => args
-    ApiMakerDevise[getScopeName] = () => scopeInstance
-  }
-
-  static getScope(scope) {
-    const scopeCamelized = inflection.camelize(scope)
-    const getScopeName = `get${scopeCamelized}Scope`
-
-    return ApiMakerDevise[getScopeName]()
-  }
-
-  static async signIn(username, password, args = {}) {
-    if (!args.scope) args.scope = "user"
-
-    const postData = {username, password, args}
-    const response = await Services.current().sendRequest("Devise::SignIn", postData)
-
-    let model = response.model
-
-    if (Array.isArray(model)) model = model[0]
-
-    ApiMakerDevise.updateSession(model)
-    events.emit("onDeviseSignIn", Object.assign({username}, args))
-
-    return {model, response}
-  }
-
-  static updateSession(model, args = {}) {
-    if (!args.scope) args.scope = "user"
-
-    const camelizedScopeName = inflection.camelize(args.scope, true)
-
-    ApiMakerDevise.current().currents[camelizedScopeName] = model
-  }
-
-  hasCurrentScope(scope) {
-    const camelizedScopeName = inflection.camelize(scope, true)
-
-    return camelizedScopeName in ApiMakerDevise.current().currents
-  }
-
-  static setSignedOut(args) {
-    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null
-  }
-
-  static async signOut(args = {}) {
-    if (!args.scope) {
-      args.scope = "user"
-    }
-
-    const response = await Services.current().sendRequest("Devise::SignOut", {args})
-
-    // Cannot use the class because they would both import each other
-    if (shared.apiMakerSessionStatusUpdater) {
-      shared.apiMakerSessionStatusUpdater.updateSessionStatus()
-    }
-
-    ApiMakerDevise.setSignedOut(args)
-    ApiMakerDevise.callSignOutEvent(args)
-
-    return response
-  }
-
-  constructor() {
-    this.currents = {}
-  }
-
-  getCurrentScope(scope) {
-    if (!(scope in this.currents)) {
-      this.currents[scope] = this.loadCurrentScope(scope)
-    }
-
-    return this.currents[scope]
-  }
-
-  hasGlobalCurrentScope(scope) {
-    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {
-      return true
-    }
-
-    return false
-  }
-
-  loadCurrentScope(scope) {
-    if (!this.hasGlobalCurrentScope(scope)) {
-      return null
-    }
-
-    const scopeData = globalThis.apiMakerDeviseCurrent[scope]
-
-    if (!scopeData) return null
-
-    const parsedScopeData = Deserializer.parse(scopeData)
-
-    // Might be a collection with preloaded relationships
-    if (Array.isArray(parsedScopeData)) return parsedScopeData[0]
-
-    const ModelClass = modelClassRequire(scope)
-    const modelInstance = new ModelClass({data: parsedScopeData})
-
-    return modelInstance
-  }
-}

package/src/draggable-sort/controller.js

@@ -1,137 +0,0 @@
-import {digg} from "diggerize"
-import EventEmitter from "events"
-
-export default class DraggableSortController {
-  constructor({data, events, keyExtractor}) {
-    this.data = data
-    this.currentOrder = [...data]
-    this.events = events || new EventEmitter()
-    this.keyExtractor = keyExtractor
-
-    this.draggedItem = null
-    this.draggedItemData = null
-    this.draggedItemNewPosition = null
-
-    this.draggedOverItem = null
-    this.draggedOverItemData = null
-
-    this.itemData = {}
-
-    for (const itemIndex in data) {
-      this.itemData[itemIndex] = {
-        index: itemIndex,
-        item: data[itemIndex],
-        position: itemIndex
-      }
-    }
-  }
-
-  getEvents = () => this.events
-  getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item))
-  getItemDataForKey = (key) => this.itemData.find((itemDataI) => digg(itemDataI, "key") == key)
-  getItemDataForIndex = (index) => digg(this, "itemData", index)
-
-  onDragStart = ({item, itemIndex}) => {
-    if (item) {
-      this.draggedItem = item
-      this.draggedItemData = this.getItemDataForIndex(itemIndex)
-      this.draggedItemIndex = itemIndex
-      this.draggedItemPosition = this.draggedItemData.position
-      this.events.emit("onDragStart", {item, itemData: this.draggedItemData})
-    }
-  }
-
-  onDragEnd = () => {
-    const itemData = this.draggedItemData
-    const fromIndex = itemData.index
-    const fromPosition = digg(this, "draggedItemPosition")
-    const toPosition = this.draggedItemNewPosition
-    const fromItem = this.draggedItem
-    const toItem = this.draggedOverItem
-    const callbackArgs = {item: itemData.item, itemData, fromIndex, fromItem, fromPosition, toItem, toPosition}
-
-    this.draggedItemData.events.emit("resetPosition", {
-      callback: () => {
-        this.events.emit("onDragEndAnimation", callbackArgs)
-      }
-    })
-
-    this.draggedItem = null
-    this.draggedItemData = null
-    this.draggedItemNewPosition = null
-
-    this.draggedOverItem = null
-    this.draggedOverItemData = null
-
-    this.events.emit("onDragEnd", callbackArgs)
-  }
-
-  onItemLayout = ({events, index, item, layout}) => {
-    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`)
-
-    const itemData = this.itemData[index]
-
-    itemData.layout = layout
-
-    if (!itemData.initialLayout) {
-      itemData.baseX = layout.x
-      itemData.events = events
-      itemData.initialLayout = layout
-      itemData.key = this.keyExtractor(item)
-    }
-  }
-
-  onMove = ({gestate}) => {
-    // Send move-event to the item being dragged so it will actually move around
-    this.draggedItemData?.events?.emit("move", {gestate})
-
-    const moveX = gestate.dx + this.initialDragPosition.x
-
-    for (const itemIndex in this.itemData) {
-      const itemData = this.getItemDataForIndex(itemIndex)
-      const baseX = digg(itemData, "baseX")
-      let smallestWidth = this.draggedItemData.layout.width
-
-      if (itemData.layout.width < smallestWidth) smallestWidth = itemData.layout.width
-
-      if (moveX > baseX && moveX < (baseX + smallestWidth) && itemIndex != this.draggedItemData.index) {
-        this.draggedOverItem = itemData.item
-        this.draggedOverItemData = itemData
-
-        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item)
-        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item)
-
-        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item
-        this.currentOrder[positionOfOverItem] = this.draggedItemData.item
-
-        this.draggedItemData.position = positionOfOverItem
-        this.draggedOverItemData.position = positionOfDraggedItem
-
-        this.updatePositionOfItems()
-        this.draggedItemNewPosition = positionOfOverItem
-      }
-    }
-  }
-
-  setInitialDragPosition = (initialDragPosition) => {
-    this.initialDragPosition = initialDragPosition
-  }
-
-  updatePositionOfItems() {
-    let currentPosition = 0
-
-    for (const item of this.currentOrder) {
-      const itemData = this.getItemDataForItem(item)
-
-      if (digg(itemData, "index") != digg(this, "draggedItemData", "index")) { // Dont animate dragged element to a new position because it is currently being dragged
-        itemData.events.emit("moveToPosition", {
-          x: currentPosition,
-          y: 0
-        })
-      }
-
-      itemData.baseX = currentPosition
-      currentPosition += digg(itemData, "layout", "width")
-    }
-  }
-}

package/src/draggable-sort/index.jsx

@@ -1,107 +0,0 @@
-import React, {useMemo} from "react"
-import {Animated, PanResponder} from "react-native"
-import {shapeComponent, ShapeComponent} from "set-state-compare/src/shape-component"
-import Controller from "./controller"
-import DraggableSortItem from "./item"
-import EventEmitter from "events"
-import memo from "set-state-compare/src/memo"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import useEventEmitter from "../use-event-emitter"
-
-export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
-  static defaultProps = {
-    horizontal: false
-  }
-
-  static propTypes = propTypesExact({
-    cacheKeyExtractor: PropTypes.func,
-    data: PropTypes.array.isRequired,
-    dataSet: PropTypes.object,
-    events: PropTypes.instanceOf(EventEmitter),
-    horizontal: PropTypes.bool.isRequired,
-    keyExtractor: PropTypes.func.isRequired,
-    onDragItemEnd: PropTypes.func,
-    onDragItemStart: PropTypes.func,
-    onItemMoved: PropTypes.func,
-    onReordered: PropTypes.func.isRequired,
-    renderItem: PropTypes.func.isRequired
-  })
-
-  setup() {
-    const {data, keyExtractor} = this.p
-    const {events} = this.props
-
-    this.controller ||= new Controller({data, events, keyExtractor})
-    this.panResponder ||= PanResponder.create({
-      onStartShouldSetPanResponder: (e) => {
-        const initialDragPosition = {x: e.nativeEvent.locationX, y: e.nativeEvent.locationY}
-
-        this.controller.setInitialDragPosition(initialDragPosition)
-
-        if (this.controller.draggedItemData) {
-          return true
-        }
-      },
-      onPanResponderMove: (e, gestate) => {
-        this.tt.controller.onMove({gestate})
-      },
-      onPanResponderRelease: (e, gestate) => {
-        if (this.controller.draggedItem) {
-          this.tt.controller.onDragEnd()
-        }
-      }
-    })
-
-    useEventEmitter(this.controller.getEvents(), "onDragStart", this.tt.onDragItemStart)
-    useEventEmitter(this.controller.getEvents(), "onDragEnd", this.tt.onDragItemEnd)
-  }
-
-  render() {
-    const {data, horizontal, keyExtractor, renderItem} = this.p
-    const {cacheKeyExtractor, dataSet} = this.props
-    const actualDataSet = useMemo(
-      () => Object.assign(
-        {component: "draggable-sort"},
-        dataSet
-      ),
-      [dataSet]
-    )
-
-    return (
-      <Animated.View
-        dataSet={actualDataSet}
-        style={this.rootViewStyle ||= {flexDirection: horizontal ? "row" : "column"}}
-        {...this.tt.panResponder.panHandlers}
-      >
-        {data.map((item, itemIndex) =>
-          <DraggableSortItem
-            cacheKey={cacheKeyExtractor ? cacheKeyExtractor(item) : undefined}
-            controller={this.tt.controller}
-            item={item}
-            itemIndex={itemIndex}
-            key={keyExtractor(item)}
-            onItemMoved={this.props.onItemMoved}
-            renderItem={renderItem}
-          />
-        )}
-      </Animated.View>
-    )
-  }
-
-  onDragItemStart = ({itemData}) => {
-    if (this.props.onDragItemStart) {
-      this.p.onDragItemStart({itemData})
-    }
-  }
-
-  onDragItemEnd = (args) => {
-    if (args.toPosition !== null) {
-      this.p.onReordered(args)
-    }
-
-    if (this.props.onDragItemEnd) {
-      this.p.onDragItemEnd(args)
-    }
-  }
-}))