@infrab4a/connect 5.7.3 → 5.7.4

package/src/utils/helpers/reflect.helper.ts

@@ -1,216 +0,0 @@
-import { first, flatten, isArray, isNil, last } from 'lodash'
-import 'reflect-metadata'
-
-type Dictionary<T> = {
-  [key: string]: T
-}
-export type MetaArgs = {
-  key: keyof MetaStorage | string
-  target: any
-  property?: string | symbol
-  own?: boolean
-  propertyDescriptor?: PropertyDescriptor
-}
-export type MetaValueArgs<T = any> = MetaArgs & {
-  value: T
-}
-type MetaProperties<T = any> = Dictionary<T>
-type MetaTargets = Dictionary<MetaProperties>
-type MetaKeys = Dictionary<MetaTargets>
-type MetaStorage = {
-  value?: any
-  object?: any
-  values?: MetaKeys
-} & Record<string, any>
-
-export class ReflectHelper {
-  private static _items: MetaStorage = {}
-
-  static get items(): MetaStorage {
-    return this._items
-  }
-
-  static get keys(): Array<string> {
-    return Object.keys(ReflectHelper.items)
-  }
-
-  static has(key: keyof MetaStorage, target?: any, property?: string | symbol): boolean {
-    return (
-      !isNil(key) &&
-      !isNil(ReflectHelper.items[key]) &&
-      (isNil(target) ||
-        (!isNil(ReflectHelper.items[key][target]) &&
-          (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)]))))
-    )
-  }
-
-  static get<T = any>({ key, target, property, own = true }: MetaArgs): Array<T> {
-    try {
-      if (own) {
-        return Reflect.getOwnMetadata(key, target, property) || null
-      } else {
-        return Reflect.getMetadata(key, target, property) || null
-      }
-    } catch {
-      return null
-    }
-  }
-
-  static first<T = any>({ key, target, property, own = true }: MetaArgs): T {
-    const values = ReflectHelper.get<T>({ key, target, property, own })
-
-    return isArray(values) ? first(values) : values
-  }
-
-  static last<T = any>({ key, target, property, own = true }: MetaArgs): T {
-    const values = ReflectHelper.get<T>({ key, target, property, own })
-
-    return isArray(values) ? last(values) : values
-  }
-
-  static set<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
-    Reflect.defineMetadata(key, value, target, property)
-
-    ReflectHelper.put<T>({ key, target, property, value, propertyDescriptor })
-  }
-
-  static add<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
-    let values: Array<T> = ReflectHelper.get<T>({ key, target, property }) || new Array<T>()
-
-    if (!Array.isArray(values)) values = [values]
-
-    values.push(value)
-
-    ReflectHelper.set<Array<T>>({ key, target, property, value: values, propertyDescriptor })
-  }
-
-  static all<T = any>({ key }: Partial<MetaArgs>): Array<MetaValueArgs<T>> {
-    const items = ReflectHelper.items[key] || {}
-
-    return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))))
-  }
-
-  static allFrom(key: string, target: any): any {
-    return Object.keys(target)
-      .filter((property) => property !== 'object')
-      .map((property) => this.allValuesFrom(key, target, property))
-  }
-
-  static allValuesFrom(key: string, target: any, property: any): any {
-    const values = target[property]
-    let value = values.value
-    const propertyDescriptor = values.propertyDescriptor
-
-    if (!isArray(value)) value = [value]
-
-    return flatten(
-      value.map((val: any) => {
-        return {
-          key,
-          target: target.object,
-          property,
-          value: val,
-          propertyDescriptor,
-        }
-      }),
-    )
-  }
-
-  static delete({ key, target, property }: MetaArgs): boolean {
-    Reflect.deleteMetadata(key, target, property)
-
-    return ReflectHelper.remove(key, target, property)
-  }
-
-  static clear(key?: string): void {
-    if (!key) {
-      ReflectHelper.keys.forEach((storedKey) => {
-        ReflectHelper.clear(storedKey)
-      })
-    } else {
-      if (ReflectHelper.keys.includes(key)) {
-        Object.values<MetaStorage>(ReflectHelper.items[key]).forEach((target) => {
-          if (ReflectHelper.has(key, target)) {
-            Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {
-              ReflectHelper.delete({
-                key,
-                target: target.object,
-                property: String(property),
-              })
-              ReflectHelper.remove(key, target, String(property))
-            })
-          }
-
-          ReflectHelper.delete({ key, target: target.object })
-          ReflectHelper.remove(key, target)
-        })
-      }
-    }
-  }
-
-  static getType({ target, propertyKey }: { target: string; propertyKey: string }): any {
-    return Reflect.getMetadata('design:type', target, propertyKey)
-  }
-
-  static getReturntype({ target, propertyKey }: { target: string; propertyKey: string }): any {
-    return Reflect.getMetadata('design:returntype', target, propertyKey)
-  }
-
-  static getAllMethods(target: any): string[] {
-    const props = []
-    let obj = target
-
-    do {
-      props.push(...Object.getOwnPropertyNames(obj))
-    } while ((obj = Object.getPrototypeOf(obj)))
-
-    return props.sort().filter((e, i, arr) => {
-      if (
-        [
-          '__defineGetter__',
-          '__defineSetter__',
-          '__lookupGetter__',
-          '__lookupSetter__',
-          'constructor',
-          'hasOwnProperty',
-          'isPrototypeOf',
-          'propertyIsEnumerable',
-          'toLocaleString',
-          'toString',
-          'valueOf',
-        ].includes(e)
-      )
-        return false
-
-      if (e != arr[i + 1] && typeof target[e] === 'function') return true
-    })
-  }
-
-  private static put<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
-    const index = target.constructor.name
-
-    ReflectHelper.items[key] = ReflectHelper.items[key] || {}
-    ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {}
-    ReflectHelper.items[key][index].object = target
-
-    if (isNil(property)) {
-      ReflectHelper.items[key][index].value = {
-        value,
-        propertyDescriptor,
-      }
-    } else {
-      ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {}
-      ReflectHelper.items[key][index][String(property)] = {
-        value,
-        propertyDescriptor,
-      }
-    }
-  }
-
-  private static remove(key: string, target?: any, property?: string | symbol): boolean {
-    if (ReflectHelper.has(key, target, property)) return delete ReflectHelper.items[key][target][String(property)]
-    else if (ReflectHelper.has(key, target)) return delete ReflectHelper.items[key][target]
-    else if (ReflectHelper.has(key)) return delete ReflectHelper.items[key]
-    else return false
-  }
-}

package/src/utils/index.ts

@@ -1,86 +0,0 @@
-import {
-  add,
-  addBusinessDays,
-  addDays,
-  addHours,
-  addMonths,
-  addYears,
-  Duration,
-  endOfDay,
-  format,
-  formatISO9075,
-  parseISO,
-  startOfDay,
-  sub,
-  subDays,
-} from 'date-fns'
-import { formatInTimeZone } from 'date-fns-tz'
-import {
-  chunk,
-  each,
-  get,
-  isBoolean,
-  isDate,
-  isEmpty,
-  isInteger,
-  isNaN,
-  isNil,
-  isNumber,
-  isObject,
-  isString,
-  now,
-  omit,
-  pick,
-  set,
-  sortBy,
-  unset,
-} from 'lodash'
-
-export type DateDuration = Duration
-
-export * from './circular-dependencies'
-export * from './decorators'
-export * from './get'
-export * from './helpers'
-export * from './is'
-export * from './is-uuid'
-export * from './log.utils'
-export * from './mixins'
-export * from './obs-emitter'
-export * from './parse-datetime'
-export * from './serialize'
-export * from './types'
-export {
-  add,
-  addBusinessDays,
-  addHours,
-  addDays,
-  addMonths,
-  addYears,
-  formatInTimeZone,
-  chunk,
-  each,
-  endOfDay,
-  format,
-  formatISO9075,
-  get,
-  isBoolean,
-  isDate,
-  isEmpty,
-  isInteger,
-  isNaN,
-  isNil,
-  isNumber,
-  isObject,
-  isString,
-  now,
-  omit,
-  parseISO,
-  pick,
-  set,
-  sortBy,
-  startOfDay,
-  sub,
-  subDays,
-  unset,
-}

package/src/utils/is-uuid.ts

@@ -1,4 +0,0 @@
-import { isString } from 'lodash'
-
-export const isUUID = (value: string): boolean =>
-  isString(value) && /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/.test(value)

package/src/utils/is.ts

@@ -1,3 +0,0 @@
-export function is<T>(value: any): T {
-  return value
-}

package/src/utils/log.utils.ts

@@ -1,9 +0,0 @@
-import { debug, Debugger } from 'debug'
-
-export enum DebugNamespaces {
-  ROOT = 'connect',
-  TRACE = 'trace',
-  ERROR = 'error',
-}
-
-export const Logger: Debugger = debug(DebugNamespaces.ROOT)

package/src/utils/mixins/base.mixin.ts

@@ -1,5 +0,0 @@
-export class Base {
-  constructor(...args: Array<any>) {
-    Object.assign(this, ...args)
-  }
-}

package/src/utils/mixins/index.ts

@@ -1,3 +0,0 @@
-export * from './mixin-ctor.type'
-export * from './base.mixin'
-export * from './merge-constructor-params.type'

package/src/utils/mixins/merge-constructor-params.type.ts

@@ -1,7 +0,0 @@
-type Tail<T extends any[]> = T extends [any, ...infer U] ? U : []
-
-export type MergeConstructorParams<NewParams extends any[], CurrentParams extends any[]> = CurrentParams extends []
-  ? [...NewParams, ...any]
-  : CurrentParams[0] extends never
-  ? [...NewParams, ...any]
-  : [...NewParams, ...Tail<CurrentParams>]

package/src/utils/mixins/mixin-ctor.type.ts

@@ -1 +0,0 @@
-export type MixinCtor<T = any, A extends any[] = any[]> = new (...args: A) => T

package/src/utils/obs-emitter.ts

@@ -1,35 +0,0 @@
-type Observer<T> = {
-  next: (value: T) => void
-}
-
-type CallbackFunction<T> = (value: T) => void
-
-type SubscriptionCallback<T> = CallbackFunction<T> | Observer<T>
-
-export class ObsEmitter<T = any> {
-  private consumers: Record<string, (value: T) => void> = {}
-
-  next(value: T) {
-    for (const key in this.consumers) this.consumers[key](value)
-  }
-
-  subscribe(callback: SubscriptionCallback<T>) {
-    const actualCallback = this.extractCallbackFunction(callback)
-
-    const namespace = Math.random().toString(36).slice(2)
-
-    this.consumers[namespace] = actualCallback
-
-    return {
-      unsubscribe: () => delete this.consumers[namespace],
-    }
-  }
-
-  private extractCallbackFunction(callback: SubscriptionCallback<T>): CallbackFunction<T> {
-    return this.isObserver(callback) ? callback.next : callback
-  }
-
-  private isObserver<T>(callback: SubscriptionCallback<T>): callback is Observer<T> {
-    return typeof callback === 'object' && callback !== null && 'next' in callback
-  }
-}

package/src/utils/parse-datetime.ts

@@ -1,18 +0,0 @@
-import { isString } from 'lodash'
-import { parseISO } from 'date-fns'
-
-export const parseDateTime = (value: string): string | Date => {
-  if (!isString(value)) return value
-
-  if (
-    !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value) &&
-    !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T\d{2}:\d{2}:\d{2}/.test(value)
-  )
-    return value
-
-  const date = parseISO(value)
-
-  if (isNaN(date.getTime())) return value
-
-  return date
-}

package/src/utils/serialize.ts

@@ -1,9 +0,0 @@
-import * as serializeJavascript from 'serialize-javascript'
-
-export const deserialize = (data: string) => {
-  return eval('(' + data + ')')
-}
-
-export const serialize = (data: any) => {
-  return serializeJavascript(data)
-}

package/src/utils/types/array-element.type.ts

@@ -1,3 +0,0 @@
-export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[]
-  ? ElementType
-  : never

package/src/utils/types/index.ts

@@ -1,2 +0,0 @@
-export * from './prop.type'
-export * from './array-element.type'

package/src/utils/types/prop.type.ts

@@ -1 +0,0 @@
-export type PropType<TObj, TProp extends keyof TObj> = TObj[TProp]

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./",
-    "declaration": true,
-    "declarationMap": true,
-    "inlineSources": true,
-    "composite": true
-  },
-  "exclude": [
-    "**/*.spec.ts"
-  ],
-  "include": ["./", "./src"]
-}

package/tsconfig.lib.json

@@ -1,12 +0,0 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "composite": false
-  },
-  "angularCompilerOptions": {
-    "skipTemplateCodegen": true,
-    "strictMetadataEmit": true,
-    "enableResourceInlining": true,
-  }
-}

package/tsconfig.lib.prod.json

@@ -1,19 +0,0 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "rootDir": "./",
-    "declarationMap": false,
-    "importHelpers": true,
-    "target": "es2020",
-    "module": "es2020",
-    "lib": ["es2020", "dom"],
-    "incremental": true,
-    "skipLibCheck": true
-  },
-  "exclude": ["teste*.ts",  "**/*.spec.ts"],
-  "include": ["./", "./src"],
-  "angularCompilerOptions": {
-    "compilationMode": "partial"
-  }
-}

package/tsconfig.spec.json

@@ -1,17 +0,0 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/spec",
-    "types": [
-      "jasmine"
-    ]
-  },
-  "files": [
-    "src/test.ts"
-  ],
-  "include": [
-    "**/*.spec.ts",
-    "**/*.d.ts"
-  ]
-}