@infrab4a/connect 5.7.2 → 5.7.3

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

@@ -0,0 +1,216 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,4 @@
+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

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

package/src/utils/log.utils.ts

@@ -0,0 +1,9 @@
+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

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

package/src/utils/mixins/index.ts

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

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

@@ -0,0 +1,7 @@
+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

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

package/src/utils/obs-emitter.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,9 @@
+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

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

package/src/utils/types/index.ts

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

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

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

package/tsconfig.json

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

package/tsconfig.lib.json

@@ -0,0 +1,12 @@
+/* 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

@@ -0,0 +1,19 @@
+/* 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

@@ -0,0 +1,17 @@
+/* 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"
+  ]
+}

package/index.cjs.d.ts

@@ -1 +0,0 @@
-export * from "./index";

package/index.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./index.cjs.js').default;