@wireio/shared 1.0.2 → 1.0.4

package/src/guards/class.ts

@@ -1,56 +0,0 @@
-/**
- * Is ES6+ class
- *
- * @see https://stackoverflow.com/questions/29093396/how-do-you-check-the-difference-between-an-ecmascript-6-class-and-function/49510834
- *
- * @param {any} value
- * @returns {boolean}
- */
-import type { ClassConstructor, TypeGuard } from "./types"
-
-export function isNativeClass <T = any>(value:any): value is ClassConstructor<T> {
-  return typeof value === 'function' && value.toString().indexOf('class') === 0
-}
-
-// Character positions
-const INDEX_OF_FUNCTION_NAME = 9  // "function X", X is at index 9
-const FIRST_UPPERCASE_INDEX_IN_ASCII = 65  // A is at index 65 in ASCII
-const LAST_UPPERCASE_INDEX_IN_ASCII = 90   // Z is at index 90 in ASCII
-
-/**
- * Is Conventional Class
- * Looks for function with capital first letter MyClass
- * First letter is the 9th character
- * If changed, isClass must also be updated
- * @param {any} value
- * @returns {boolean}
- */
-export function isConventionalClass <T = any>(value:any): value is ClassConstructor<T> {
-  if ( typeof value !== 'function' )  return false
-  const c = value.toString().charCodeAt(INDEX_OF_FUNCTION_NAME)
-  return c >= FIRST_UPPERCASE_INDEX_IN_ASCII && c <= LAST_UPPERCASE_INDEX_IN_ASCII
-}
-
-
-export function isClass<T = any>(value: any, includeConventional: boolean = true): value is ClassConstructor<T> {
-  return isNativeClass<T>(value) || (includeConventional && isConventionalClass<T>(value))
-}
-
-
-
-
-
-export function createInstanceOfGuard<T, Ctor extends ClassConstructor<T>>(ctor: Ctor): ((o: any) => o is T) {
-  return (o: any): o is T => o instanceof ctor
-}
-
-export function instanceOf<T extends {}, Ctor extends ClassConstructor<T>>(ctor: Ctor) {
-  return createInstanceOfGuard<T,Ctor>(ctor)
-} 
-
-export function createGenericGuard<T>(tester: (val:any) => val is T):TypeGuard<T>
-export function createGenericGuard<T>(type:{new():T}, tester: (val:any) => val is T):TypeGuard<T>
-export function createGenericGuard<T>(typeOrTest: ({new():T} | ((val:any) => val is T)), tester?: (val:any) => val is T) {
-  return tester as TypeGuard<T>
-}
-

package/src/guards/guard-tools.ts

@@ -1,78 +0,0 @@
-import { isNil, isPromise } from "./primitive.js"
-import type { ErrorHandler } from "./types.js"
-
-export type GuardErrorHandler = (err:Error) => void
-
-let globalErrorHandler:GuardErrorHandler | null
-
-export function setGuardErrorHandler(errorHandler:GuardErrorHandler | null = null) {
-	globalErrorHandler = errorHandler
-}
-
-export type ReturnTypeOrAny<Fn extends () => any> = (ReturnType<Fn> extends never ? unknown : ReturnType<Fn>)
-
-
-/**
- * Get a value in a guarded fashion
- * ensuring no exception
- *
- * @param fn
- * @param defaultValue
- * @returns {any}
- * @param errorHandler
- */
-export function getValue<Fn extends () => any, T extends ReturnType<Fn> >(
-	fn:Fn,
-	defaultValue: T = undefined,
-	errorHandler: ErrorHandler = globalErrorHandler
-):T extends Promise<infer T2> ? Promise<T2> : T {
-	
-	let result = null
-
-	try {
-		result = fn()
-		if (isPromise(result))
-			return result
-				.catch(err => {
-					if (errorHandler)
-						errorHandler(err)
-
-					return defaultValue
-				})
-				.then(value => isNil(value) ? defaultValue : value) as any
-	} catch (err) {
-		if (errorHandler)
-			errorHandler(err)
-	}
-
-	return isNil(result) ?
-		(defaultValue as any) : result
-}
-
-
-export type GuardFn = <Fn extends () => any, T extends ReturnType<Fn> >(fn:Fn, localErrorHandler?: GuardErrorHandler | null) => (void | Promise<void>)
-export type GuardTool = GuardFn & {
-	lift: <T>(fn:() => T, localErrorHandler?: GuardErrorHandler | null) => ((fn:() => T, localErrorHandler?: GuardErrorHandler | null) => (void | Promise<void>))
-}
-
-
-
-/**
- * Execute a function guarded from exception
- *
- * @param fn
- * @param localErrorHandler
- * @returns {(fn:()=>any)=>(fn:()=>any)=>any}
- */
-const guardFn:GuardFn = <Fn extends () => any, T extends ReturnType<Fn> >(fn:Fn, localErrorHandler: ((err: Error) => void) | null = null):void | Promise<void> => {
-	const value = getValue<Fn,T>(fn, undefined, localErrorHandler)
-	if (isPromise(value))
-		return value.then(() => undefined as void)
-	
-}
-
-export const guard: GuardTool = Object.assign(guardFn, {
-	lift: <Fn extends () => any, T extends ReturnType<Fn> >(fn:Fn, localErrorHandler?: GuardErrorHandler | null) =>
-		(fn:Fn, localErrorHandler?: GuardErrorHandler | null): (void | Promise<void>) =>
-			guardFn<Fn,T>(fn,localErrorHandler)
-})

package/src/guards/index.ts

@@ -1,7 +0,0 @@
-export * from "./class.js"
-export * from "./array.js"
-export * from "./types.js"
-export * from "./primitive.js"
-export * from "./types.js"
-export * from "./assert.js"
-export * from "./guard-tools.js"

package/src/guards/primitive.ts

@@ -1,77 +0,0 @@
-import _isNil from 'lodash/isNil.js'
-import _isObject from 'lodash/isObject.js'
-import _isString from 'lodash/isString.js'
-import _isNumber from 'lodash/isNumber.js'
-import _isFunction from 'lodash/isFunction.js'
-import { applyTypeGuardExtras } from "./applyTypeGuardExtras.js";
-
-
-export type UndefinedOrNull = undefined|null
-
-
-
-export function isNil(o:any):o is UndefinedOrNull {
-	return _isNil(o)
-}
-
-/**
- * O is a valid object
- *
- * @param o
- */
-export function isDefined<T>(o:any):o is Exclude<T, UndefinedOrNull>
-export function isDefined(o:any):o is Exclude<any,UndefinedOrNull>
-export function isDefined(o:any) {
-	return !isNil(o)
-}
-
-export function isObject(o:any):o is Object {
-	return !isNil(o) && _isObject(o)
-}
-
-export function isPromise(o:any):o is Promise<any> {
-	return !isNil(o) && isObject(o) && (o instanceof Promise || isFunction(o.then))
-}
-
-
-export function isObjectType<T>(o:any,type:{new():T}):o is T {
-	return !isNil(o) && (o instanceof type || o.$$clazz === type.name)
-}
-
-export function isString(o:any):o is string {
-	return !isNil(o) && _isString(o)
-}
-
-export function isNumber(o:any):o is number {
-	return !isNil(o) && _isNumber(o) && !isNaN(o)
-}
-
-export const isFunction = applyTypeGuardExtras<Function>(function isFunction(o:any):o is Function {
-	return !isNil(o) && _isFunction(o)
-})
-
-export function isSymbol(o:any):o is Symbol {
-	return !isNil(o) && typeof o === 'symbol'
-}
-
-export function isBoolean(o: any): o is boolean {
-	return typeof o === "boolean"
-}
-
-export function isDate(o: any): o is Date {
-	return o instanceof Date
-}
-
-export type Primitive = boolean | string | number
-
-export type PrimitiveProducer<P extends Primitive = Primitive> = (...args: any[]) => P
-
-export const PrimitiveProducers = Array<PrimitiveProducer>(String, Number, Boolean)
-
-export function isPrimitiveProducer<P extends Primitive = Primitive>(o:any): o is PrimitiveProducer<P> {
-	return PrimitiveProducers.includes(o)
-}
-
-export function isPrimitive(o:any): o is Primitive {
-	return isBoolean(o) || isString(o) || isNumber(o)
-}

package/src/guards/types.ts

@@ -1,15 +0,0 @@
-export type TypeGuard<T> = (o:any) => o is T
-
-export type ClassConstructor<T> = new (...args:any[]) => T
-
-export type LiftTypeGuard<T> = () => boolean
-
-export type TypeGuardExtras<T> = TypeGuard<T> & {
-  lift: (o:any) => LiftTypeGuard<T>
-}
-
-export type Optional<T> = T | null | undefined
-
-export type ErrorHandler<E extends Error = Error> = (err: E) => void
-
-export {}

package/src/helpers/Deferred.ts

@@ -1,149 +0,0 @@
-import { isDefined, isPromise } from "../guards/index.js"
-
-export enum DeferredStatus {
-  PENDING = "PENDING",
-  FULFILLED = "FULFILLED",
-  REJECTED = "REJECTED",
-  CANCELED = "CANCELED"
-}
-
-/**
- * Internal deferred state
- */
-interface DeferredState<T> {
-  resolve: (result?:T) => void
-  reject: (err:any) => void
-  isSettled: boolean
-  isCancelled: boolean
-  isRejected: boolean
-  isFulfilled: boolean
-  result:T | null
-  err: Error | null
-}
-
-/**
- * A deferred promise that can be resolved or rejected
- * externally, ideal for functions like a promise timeout
- */
-export class Deferred<T> {
-  
-
-  static async delay(millis:number) {
-    const deferred = new Deferred<void>()
-    setTimeout(() => deferred.resolve(),millis)
-    await deferred.promise
-  }
-  
-  static resolve<T>(value?:T): Deferred<T> {
-    const deferred = new Deferred<T>()
-    deferred.resolve(value)
-    return deferred
-  }
-  
-  private readonly state:DeferredState<T>
-  
-  readonly promise:Promise<T>
-
-  
-  constructor(promise?:Promise<T> | undefined) {
-    this.state = {
-      resolve: null,
-      reject: null,
-      isSettled: false,
-      isCancelled: false,
-      isRejected: false,
-      isFulfilled: false,
-      result: null,
-      err: null
-    }
-    
-    this.promise = new Promise<T>((resolve, reject) => {
-      Object.assign(this.state, {
-        resolve,
-        reject
-      })
-    })
-    
-    if (isDefined(promise)) {
-      if (promise instanceof Promise || isPromise(promise)) {
-        promise
-          .then(this.state.resolve)
-          .catch(this.state.reject)
-      } else {
-        throw Error(`An existing promise was provided to Deferred constructor, but it wasn't a valid promise`)
-      }
-    }
-  }
-  
-  isFulfilled(): boolean {
-    return this.state.isFulfilled
-  }
-  
-  isRejected(): boolean {
-    return this.state.isRejected
-  }
-  
-  isSettled(): boolean {
-    return this.state.isSettled
-  }
-  
-  isCancelled(): boolean {
-    return this.state.isCancelled
-  }
-  
-  status(): DeferredStatus {
-    return this.isCancelled() ? DeferredStatus.CANCELED : this.isSettled() ? this.isFulfilled() ? DeferredStatus.FULFILLED : DeferredStatus.REJECTED : DeferredStatus.PENDING
-  }
-  
-  cancel(): void {
-    this.state.isSettled = true
-    this.state.isCancelled = true
-  }
-  
-  resolve(result?:T): void {
-    if (!this.state.isSettled && !this.state.isCancelled) {
-      Object.assign(this.state, {
-        result: result,
-        isSettled: true,
-        isFulfilled: true
-      })
-      this.state.resolve(result)
-    }
-  }
-  
-  reject(err:any): void {
-    if (!this.state.isSettled && !this.state.isCancelled) {
-      Object.assign(this.state, {
-        isSettled: true,
-        isRejected: true,
-        err
-      })
-      
-      
-      
-      this.state.reject(err)
-    }
-  }
-  
-  get error() {
-    return this.getError()
-  }
-  
-  get value() {
-    return this.getResult()
-  }
-  
-  getError(): Error | undefined {
-    if(!this.isSettled())
-      throw Error("Deferred promise is not settled, result is not available")
-    return this.state.err
-  }
-  
-  getResult():T {
-    if(!this.isSettled())
-      throw Error("Deferred promise is not settled, result is not available")
-    return this.state.result
-  }
-}
-
-export default Deferred

package/src/helpers/index.ts

@@ -1 +0,0 @@
-export * from "./Deferred.js"

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./guards/index.js"
-export * from "./helpers/index.js"
-export * from "./logging/index.js"

package/src/logging/Appender.ts

@@ -1,5 +0,0 @@
-import { LogRecord } from "./LogRecord.js"
-
-export interface Appender<Record extends LogRecord = any> {
-  append(record: Record): void
-}

package/src/logging/Formatter.ts

@@ -1,8 +0,0 @@
-import type { LogRecord } from "./LogRecord"
-
-export type Formatter<
-  Output,
-  Context extends {} = {},
-  Data = any,
-  Record extends LogRecord<Data> = LogRecord<Data>
-> = (record: Record, options?: Context) => Output

package/src/logging/InternalLogger.ts

@@ -1,6 +0,0 @@
-const GLOBAL_CATEGORY = "GLOBAL"
-
-export function getInternalLogger(category: string = GLOBAL_CATEGORY) {
-  category = category.split("/").pop().replace(/\.[a-z]+$/,"") ?? GLOBAL_CATEGORY
-  return console
-}

package/src/logging/Level.ts

@@ -1,19 +0,0 @@
-import { fromPairs, uniq } from "lodash"
-
-export enum Level {
-  trace = "trace",
-  debug = "debug",
-  info = "info",
-  warn = "warn",
-  error = "error",
-  fatal = "fatal"
-}
-
-export type LevelName = `${Level}`
-export type LevelKind = LevelName | Level
-
-export const LevelNames: Array<LevelName> = uniq(Object.values(Level))
-export const LevelThresholds = fromPairs(
-  LevelNames.map((level, i) => [level, i])
-) as Record<LevelKind, number>
-export type LevelEnableFnName = `is${Capitalize<LevelName>}Enabled`

package/src/logging/LogRecord.ts

@@ -1,17 +0,0 @@
-import { fromPairs, uniq } from "lodash"
-import type { Level, LevelKind, LevelName } from "./Level"
-
-export interface LogRecord<Data = any> {
-  timestamp: number
-  category: string
-  level: LevelKind
-  message: string
-  args?: any[]
-  data?: Data
-  tags?: string[]
-  url?: string
-  env?: string
-  event?: string
-  errorMessage?: string
-  errorStack?: string
-}

package/src/logging/Logger.ts

@@ -1,222 +0,0 @@
-import { assert, getValue, isString, isDefined, isFunction, isNumber } from "../guards/index.js"
-import { Option } from "prelude-ts"
-import { pick } from "lodash"
-import { LevelKind, LevelThresholds } from "./Level.js"
-import type { LoggingManager } from "./LoggingManager.js"
-import type { LogRecord } from "./LogRecord.js"
-import { isLogLevelKind } from "./util.js"
-
-export interface LoggerOptions {
-  categoryInterpolator: CategoryInterpolator
-}
-
-export type CategoryInterpolator = (
-  inCategory: string,
-  options?: LoggerOptions
-) => string
-
-export const filenameCategoryInterpolator: CategoryInterpolator = (
-  filename: string
-) => {
-  const allParts = filename.replaceAll("\\","/").split("/")
-  const rootIndex = Math.max(
-    ...["src", "lib"].map((name) => allParts.indexOf(name))
-  )
-  const parts =
-    rootIndex === -1 ? [allParts.pop()] : allParts.slice(rootIndex + 1)
-  const category = Option.of(parts.join(":"))
-    .flatMap((cat) =>
-      Option.of(cat.lastIndexOf(".")).map((index) =>
-        index === -1 ? cat : cat.slice(0, index)
-      )
-    )
-    .getOrElse("unknown")
-  return category
-}
-
-export const defaultLoggerOptions: LoggerOptions = {
-  categoryInterpolator: filenameCategoryInterpolator
-}
-
-export function toLogRecord(
-  logger: Logger,
-  levelOrRecord: LevelKind | LogRecord,
-  args: any[]
-) {
-  const errRecord = Option.ofNullable(
-    args.find((arg) => (isString(arg?.message) && !!arg.stack) || arg instanceof Error)
-  ).match({
-    Some: (err) => ({
-      errorMessage: getValue(() => err.message),
-      errorStack: getValue(() => err.stack)  
-    }),
-    None: () => ({})
-  })
-
-  const recordBase = isString(levelOrRecord)
-    ? ({
-        ...pick(logger, ["category"]),
-        timestamp: Date.now(),
-        message: args[0],
-        level: levelOrRecord,
-        args: args.slice(1)
-      } as LogRecord)
-    : levelOrRecord
-  return {
-    ...recordBase,
-    ...errRecord,
-    timestamp: isNumber(recordBase.timestamp) && recordBase.timestamp > 0 ? recordBase.timestamp : Date.now(),
-  }
-}
-
-export interface LoggerState {
-  overrideLevel?: LevelKind
-}
-
-export class Logger {
-  readonly state: LoggerState = {
-    overrideLevel: null
-  }
-
-  get overrideLevel(): LevelKind {
-    return Option.ofNullable(this.state.overrideLevel)
-      .filter(isLogLevelKind) //Predicate.of<LevelKind>(isString).and(isLogLevelKind))
-      .getOrNull()
-  }
-
-  get overrideThreshold() {
-    return Option.ofNullable(this.overrideLevel)
-      .map((level) => LevelThresholds[level])
-      .getOrNull()
-  }
-
-  setOverrideLevel(inOverrideLevel: LevelKind) {
-    const overrideLevel = (
-      !inOverrideLevel ? null : inOverrideLevel.toLocaleLowerCase()
-    ) as LevelKind
-
-    assert(
-      !isDefined(overrideLevel) || isLogLevelKind(overrideLevel),
-      `Invalid override level, must be a log level, all lower case`
-    )
-
-    Object.assign(this.state, {
-      overrideLevel
-    })
-
-    return this
-  }
-
-  /**
-   * Base logging function
-   *
-   * @param record
-   */
-  log(record: LogRecord):void
-  log(level: LevelKind, message: string, ...args: any[]):void
-  log(levelOrRecord: LevelKind | LogRecord, ...args: any[]) {
-    const record = toLogRecord(this, levelOrRecord, args)
-    this.manager.fire(record)
-  }
-
-  /**
-   * Factory for the log
-   * level functions
-   *
-   * @param {LevelKind} level
-   * @returns {(message: string, ...args: any[]) => void}
-   * @private
-   */
-  private createLevelLogger(level: LevelKind): (message: string, ...args: any[]) => void {
-    const isEnabled = this.createLevelEnabled(level)
-    return (message: string, ...args: any[]) => {
-      if (isEnabled()) {
-        this.log(level, message, ...args)
-      }
-    }
-  }
-
-  /**
-   * Factory for is<Level>Enabled
-   *
-   * @param {LevelKind} level
-   * @returns {() => boolean}
-   * @private
-   */
-  private createLevelEnabled(level: LevelKind): () => boolean {
-    return () => {
-      const { rootThreshold } = this.manager
-
-      const globalOverrideThreshold = this.manager.determineThresholdOverride(this.category)
-      const categoryThresholds = [
-        globalOverrideThreshold,
-        rootThreshold,
-        this.overrideThreshold
-      ].filter(isNumber)
-
-      const categoryThreshold = Math.min(...categoryThresholds)
-
-      const recordThreshold = LevelThresholds[level]
-
-      return recordThreshold >= categoryThreshold
-    }
-  }
-
-  readonly trace = this.createLevelLogger("trace")
-  readonly debug = this.createLevelLogger("debug")
-  readonly info = this.createLevelLogger("info")
-  readonly warn = this.createLevelLogger("warn")
-  readonly error = this.createLevelLogger("error")
-  readonly fatal = this.createLevelLogger("fatal")
-
-  readonly isTraceEnabled = this.createLevelEnabled("trace")
-  readonly isDebugEnabled = this.createLevelEnabled("debug")
-  readonly isInfoEnabled = this.createLevelEnabled("info")
-  readonly isWarnEnabled = this.createLevelEnabled("warn")
-  readonly isErrorEnabled = this.createLevelEnabled("error")
-  readonly isFatalEnabled = this.createLevelEnabled("fatal")
-  
-  assert(test: boolean | (() => boolean), message: string, ...args: any[]) {
-    const isTruthy = isFunction(test) ? test() : test
-    if (isTruthy) {
-      return
-    }
-    
-    this.error(message, ...args)
-}
-  
-  assertFatal(test: boolean | (() => boolean), message: string, exitCode: number = 1) {
-    const isTruthy = isFunction(test) ? test() : test
-    if (isTruthy) {
-      return
-    }
-    
-    this.fatal("FATAL ASSERTION: ", message)
-    if (typeof process !== "undefined") {
-      process.exit(exitCode)
-    } else {
-      console.error("FATAL ASSERTION: `process` is not defined, probably in a web browser")
-    }
-  }
-  
-  constructor(
-    readonly manager: LoggingManager,
-    readonly category: string,
-    readonly options: LoggerOptions
-  ) {}
-
-  static hydrateOptions(options: Partial<LoggerOptions> = {}): LoggerOptions {
-    return {
-      ...defaultLoggerOptions,
-      ...options
-    }
-  }
-
-  static interoplateCategory(category: string, options: LoggerOptions) {
-    options = {
-      ...defaultLoggerOptions,
-      ...options
-    }
-    return options.categoryInterpolator(category, options)
-  }
-}