@wireio/shared 1.0.2 → 1.0.3

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@wireio/shared",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "lib",
+    "README.md"
+  ],
   "type": "module",
   "types": "lib/index.d.ts",
   "module": "lib/index.js",

package/src/guards/applyTypeGuardExtras.ts

@@ -1,9 +0,0 @@
-import type { TypeGuard, TypeGuardExtras } from "./types"
-
-
-export function applyTypeGuardExtras<T>(fn:TypeGuard<T>):TypeGuardExtras<T> {
-  (
-    fn as TypeGuardExtras<T>
-  ).lift = (o:any) => () => fn(o)
-  return fn as TypeGuardExtras<T>
-}

package/src/guards/array.ts

@@ -1,5 +0,0 @@
-export function isArray(
-  o: unknown
-): o is Array<typeof o extends Array<infer T> ? T : any> {
-  return Array.isArray(o)
-}

package/src/guards/assert.ts

@@ -1,83 +0,0 @@
-import { isFunction, isString } from "./primitive.js"
-
-export interface AssertOptions {
-  logErrorsToConsole: boolean
-}
-
-export const DefaultAssertOptions:AssertOptions = {
-  logErrorsToConsole: false
-}
-
-let assertOptions:AssertOptions = {...DefaultAssertOptions}
-
-export function getAssertOptions() {
-  return {...assertOptions}
-}
-
-export function setGlobalAssertOptions(options: AssertOptions) {
-  assertOptions = {...assertOptions, ...options}
-}
-
-export class AssertError extends Error {
-  
-  
-  
-  constructor(message: string,  public readonly cause?: Error) {
-    super(message)
-  }
-}
-
-
-const assertLift:AssertLift = <T>(test: (value:T) => boolean, messageProvider: string | ((value: T) => string)) => {
-  return (nextValue: T) => {
-    const ok = test(nextValue)
-    if (!ok) {
-      const message = isFunction(messageProvider) ? messageProvider(nextValue) : messageProvider ?? "no message"
-      throw new AssertError(message)
-    }
-  }
-}
-
-export type AssertLift = <T>(test: (value:T) => boolean, message: string | ((value: T) => string)) =>
-  (nextValue: T) => void | never
-
-export interface Assert {
-  (
-    test: (() => boolean) | boolean,
-    msg?: null | ((err?: Error) => Error | string) | Error | string | undefined,
-    overrideOptions?: Partial<AssertOptions>
-  ): void | never
-  
-  lift: AssertLift
-}
-
-
-export const assert: Assert = Object.assign((
-  test: (() => boolean) | boolean,
-  msg?: null | ((err?: Error) => Error | string) | Error | string | undefined,
-  overrideOptions: Partial<AssertOptions> = {}
-): void | never => {
-  const options = {...assertOptions, ...overrideOptions}
-  let result: boolean = false
-  let error: Error = undefined
-  
-  try {
-    result = isFunction(test) ? test() : test
-  } catch (err) {
-    error = err
-    if (options.logErrorsToConsole) {
-      console.error(`Assert failed: "${test}"`, err)
-    }
-  }
-  
-  if (!result || !!error) {
-    const errOut = !msg ? (error?.message ?? "unknown") :
-      isFunction(msg) ? msg(error) :
-        msg
-    throw isString(errOut) ? new AssertError(errOut, error) : errOut
-  }
-}, {
-  lift: assertLift
-})
-
-

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
-}