@bessemer/cornerstone 0.5.0

package/src/expression/expression.ts

@@ -0,0 +1,188 @@
+import { ExpressionEvaluator } from '@bessemer/cornerstone/expression/expression-evaluator'
+import {
+  ArrayExpressions,
+  EvaluateExpression,
+  Expression,
+  ExpressionContext,
+  ExpressionDefinition,
+  ExpressionReference,
+  ExpressionVariable,
+  NumericExpressions,
+  ParameterizedVariable,
+  StringExpressions,
+} from '@bessemer/cornerstone/expression'
+import { Arrays, Objects, Preconditions, Signatures } from '@bessemer/cornerstone'
+import { Signable } from '@bessemer/cornerstone/signature'
+import { defineExpression } from '@bessemer/cornerstone/expression/internal'
+import { UnknownRecord } from 'type-fest'
+
+export const evaluate = <T>(expression: Expression<T>, context: ExpressionContext): T => {
+  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context)
+}
+
+export const evaluateDefault = <T>(expression: Expression<T>): T => {
+  return evaluate(expression, defaultContext())
+}
+
+export const evaluator = (context: ExpressionContext): EvaluateExpression => {
+  return (it) => evaluate(it, context)
+}
+
+export const defaultEvaluator = (): EvaluateExpression => {
+  return evaluator(defaultContext())
+}
+
+export const defaultContext = (): ExpressionContext => {
+  return { variables: {} }
+}
+
+export const dereference = <ReturnType, ArgumentType extends Array<unknown>>(
+  reference: ExpressionReference<ReturnType, ArgumentType>,
+  ...args: ArgumentType
+): Expression<ReturnType> => {
+  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).dereference(reference, ...args)
+}
+
+export const parameterizedVariable = <ValueType, ParameterType extends Array<Signable>>(
+  name: string
+): ParameterizedVariable<ValueType, ParameterType> => {
+  return {
+    apply(...parameters: ParameterType): ExpressionVariable<ValueType> {
+      const parameterString = parameters.map(Signatures.sign).join('.')
+      return variable(`${name}.${parameterString}`)
+    },
+  }
+}
+
+export const buildVariable = <T>(variable: ExpressionVariable<T>, value: T): UnknownRecord => {
+  return { [variable.name]: value }
+}
+
+export const reference = <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(
+  expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>
+): ExpressionReference<ReturnType, ArgumentType> => {
+  return { expressionKey: expressionDefinition.expressionKey }
+}
+
+export const ValueExpression = defineExpression({
+  expressionKey: 'Value',
+  builder: (value: unknown) => {
+    return { value }
+  },
+  resolver: ({ value }, evaluate, context) => {
+    return value
+  },
+})
+
+export const value = <T>(value: T): Expression<T> => ValueExpression.builder(value) as Expression<T>
+
+export const VariableExpression = defineExpression({
+  expressionKey: 'Variable',
+  builder: (name: string) => {
+    return { name }
+  },
+  resolver: ({ name }, evaluate, context) => {
+    const value = context.variables[name]
+    Preconditions.isPresent(value)
+    return value
+  },
+})
+
+export const variable = <T>(name: string): ExpressionVariable<T> => VariableExpression.builder(name) as ExpressionVariable<T>
+
+export const NotExpression = defineExpression({
+  expressionKey: 'Not',
+  builder: (value: Expression<boolean>) => {
+    return { value }
+  },
+  resolver: (expression, evaluate) => {
+    return !evaluate(expression.value)
+  },
+})
+
+export const not = NotExpression.builder
+
+export const AndExpression = defineExpression({
+  expressionKey: 'And',
+  builder: (operands: Array<Expression<boolean>>) => {
+    return { operands }
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it))
+    const falseValue = values.find((it) => !it)
+    return Objects.isNil(falseValue)
+  },
+})
+
+export const and = AndExpression.builder
+
+export const OrExpression = defineExpression({
+  expressionKey: 'Or',
+  builder: (operands: Array<Expression<boolean>>) => {
+    return { operands }
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it))
+    const trueValue = values.find((it) => it)
+    return Objects.isPresent(trueValue)
+  },
+})
+
+export const or = OrExpression.builder
+
+export const EqualsExpression = defineExpression({
+  expressionKey: 'Equals',
+  builder: (operands: Array<Expression<Signable>>) => {
+    return { operands }
+  },
+  resolver: (expression, evaluate) => {
+    const values = expression.operands.map((it) => evaluate(it)).map(Signatures.sign)
+
+    if (values.length === 0) {
+      return true
+    }
+
+    const first = values[0]
+    return values.every((val) => val === first)
+  },
+})
+
+export const equals = EqualsExpression.builder
+
+export const ContainsExpression = defineExpression({
+  expressionKey: 'Contains',
+  builder: (collection: Expression<Array<Signable>>, operands: Array<Expression<Signable>>) => {
+    return { collection, operands }
+  },
+  resolver: (expression, evaluate) => {
+    const collection = evaluate(expression.collection)
+    const values = expression.operands.map((it) => evaluate(it))
+    return Arrays.containsAll(collection, values)
+  },
+})
+
+export const contains = ContainsExpression.builder
+
+const DEFAULT_EXPRESSION_DEFINITIONS: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>> = [
+  ValueExpression,
+  VariableExpression,
+  AndExpression,
+  OrExpression,
+  ContainsExpression,
+  EqualsExpression,
+  NumericExpressions.SumExpression,
+  NumericExpressions.MultiplyExpression,
+  NumericExpressions.GreaterThanExpression,
+  NumericExpressions.LessThanExpression,
+  NumericExpressions.FloorExpression,
+  NumericExpressions.CeilingExpression,
+  NumericExpressions.BoundsExpression,
+  NumericExpressions.RoundExpression,
+  NumericExpressions.MaxExpression,
+  NumericExpressions.MinExpression,
+  StringExpressions.ConcatenateExpression,
+  StringExpressions.SubstringExpression,
+  StringExpressions.UppercaseExpression,
+  ArrayExpressions.ConcatenateExpression,
+  ArrayExpressions.FirstExpression,
+]

package/src/expression/internal.ts

@@ -0,0 +1,34 @@
+import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionKey, IExpression } from '@bessemer/cornerstone/expression'
+import { Objects } from '@bessemer/cornerstone'
+import { UnknownRecord } from 'type-fest'
+
+export const defineExpression = <ReturnType, ArgumentType extends Array<unknown>, PayloadType extends UnknownRecord>(options: {
+  expressionKey: ExpressionKey<ReturnType, ArgumentType>
+  builder: (...parameters: ArgumentType) => PayloadType
+  resolver: (expression: PayloadType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType
+}): ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType> => {
+  return {
+    expressionKey: options.expressionKey,
+    builder: (...parameters) => {
+      return { expressionKey: options.expressionKey, ...options.builder(...parameters) }
+    },
+    resolver: (expression, evaluate, context) => {
+      return options.resolver(expression as any, evaluate, context)
+    },
+  }
+}
+
+export const isType = <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(
+  expression: Expression<ReturnValue>,
+  expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>
+): expression is ReturnType<typeof expressionDefinition['builder']> => {
+  if (!isExpression(expression)) {
+    return false
+  }
+
+  return expression.expressionKey === expressionDefinition.expressionKey
+}
+
+export const isExpression = <T>(expression: Expression<any>): expression is IExpression<T> => {
+  return Objects.isObject(expression) && 'expressionKey' in expression
+}

package/src/expression/numeric-expression.ts

@@ -0,0 +1,182 @@
+import { defineExpression, isType } from '@bessemer/cornerstone/expression/internal'
+import { Expression } from '@bessemer/cornerstone/expression'
+import { Maths, Objects } from '@bessemer/cornerstone'
+import { RoundingMode } from '@bessemer/cornerstone/math'
+
+export const SumExpression = defineExpression({
+  expressionKey: 'Numeric.Sum',
+  builder: (initialOperands: Array<Expression<number>>) => {
+    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {
+      if (isType(it, SumExpression)) {
+        return it.operands
+      } else {
+        return [it]
+      }
+    })
+
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it))
+    return values.reduce((x, y) => x + y, 0)
+  },
+})
+
+export const sum = SumExpression.builder
+
+export const MultiplyExpression = defineExpression({
+  expressionKey: 'Numeric.Multiply',
+  builder: (initialOperands: Array<Expression<number>>) => {
+    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {
+      if (isType(it, MultiplyExpression)) {
+        return it.operands
+      } else {
+        return [it]
+      }
+    })
+
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it))
+    return values.reduce((x, y) => x * y, 1)
+  },
+})
+
+export const multiply = MultiplyExpression.builder
+
+export const LessThanExpression = defineExpression({
+  expressionKey: 'Numeric.LessThan',
+  builder: (left: Expression<number>, right: Expression<number>) => {
+    return { left, right }
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) < evaluate(right)
+  },
+})
+
+export const lessThan = LessThanExpression.builder
+
+export const GreaterThanExpression = defineExpression({
+  expressionKey: 'Numeric.GreaterThan',
+  builder: (left: Expression<number>, right: Expression<number>) => {
+    return { left, right }
+  },
+  resolver: ({ left, right }, evaluate) => {
+    return evaluate(left) > evaluate(right)
+  },
+})
+
+export const greaterThan = GreaterThanExpression.builder
+
+export const BoundsExpression = defineExpression({
+  expressionKey: 'Numeric.Bounds',
+  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null, maximumThreshold: Expression<number> | null) => {
+    return { value, minimumThreshold, maximumThreshold }
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value)
+    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null
+    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null
+    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {
+      value = minimumThreshold
+    }
+    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {
+      value = maximumThreshold
+    }
+
+    return value
+  },
+})
+
+export const bounds = BoundsExpression.builder
+
+export const FloorExpression = defineExpression({
+  expressionKey: 'Numeric.Floor',
+  builder: (value: Expression<number>, minimumThreshold: Expression<number> | null) => {
+    return { value, minimumThreshold }
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value)
+    const minimumThreshold = Objects.isPresent(expression.minimumThreshold) ? evaluate(expression.minimumThreshold) : null
+    if (Objects.isPresent(minimumThreshold) && value < minimumThreshold) {
+      value = minimumThreshold
+    }
+
+    return value
+  },
+})
+
+export const floor = FloorExpression.builder
+
+export const CeilingExpression = defineExpression({
+  expressionKey: 'Numeric.Ceiling',
+  builder: (value: Expression<number>, maximumThreshold: Expression<number> | null) => {
+    return { value, maximumThreshold }
+  },
+  resolver: (expression, evaluate) => {
+    let value = evaluate(expression.value)
+    const maximumThreshold = Objects.isPresent(expression.maximumThreshold) ? evaluate(expression.maximumThreshold) : null
+    if (Objects.isPresent(maximumThreshold) && value > maximumThreshold) {
+      value = maximumThreshold
+    }
+
+    return value
+  },
+})
+
+export const ceiling = CeilingExpression.builder
+
+export const RoundExpression = defineExpression({
+  expressionKey: 'Numeric.Round',
+  builder: (value: Expression<number>, scale: number, roundingMode: RoundingMode) => {
+    return { value, scale, roundingMode }
+  },
+  resolver: ({ value, scale, roundingMode }, evaluate) => {
+    return Maths.round(evaluate(value), scale, roundingMode)
+  },
+})
+
+export const round = RoundExpression.builder
+
+export const MinExpression = defineExpression({
+  expressionKey: 'Numeric.Min',
+  builder: (initialOperands: Array<Expression<number>>) => {
+    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {
+      if (isType(it, MinExpression)) {
+        return it.operands
+      } else {
+        return [it]
+      }
+    })
+
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it))
+    return Math.min(...values)
+  },
+})
+
+export const min = MinExpression.builder
+
+export const MaxExpression = defineExpression({
+  expressionKey: 'Numeric.Max',
+  builder: (initialOperands: Array<Expression<number>>) => {
+    const operands: Array<Expression<number>> = initialOperands.flatMap((it) => {
+      if (isType(it, MaxExpression)) {
+        return it.operands
+      } else {
+        return [it]
+      }
+    })
+
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = operands.map((it) => evaluate(it))
+    return Math.max(...values)
+  },
+})
+
+export const max = MaxExpression.builder

package/src/expression/string-expression.ts

@@ -0,0 +1,38 @@
+import { defineExpression } from '@bessemer/cornerstone/expression/internal'
+import { Expression } from '@bessemer/cornerstone/expression'
+
+export const ConcatenateExpression = defineExpression({
+  expressionKey: 'Concatenate',
+  builder: (first: Expression<string>, second: Expression<string>) => {
+    return { first, second }
+  },
+  resolver: (): string => {
+    throw new Error('Not yet implemented')
+  },
+})
+
+export const concatenate = ConcatenateExpression.builder
+
+export const UppercaseExpression = defineExpression({
+  expressionKey: 'Uppercase',
+  builder: (value: Expression<string>) => {
+    return { value }
+  },
+  resolver: (): string => {
+    throw new Error('Not yet implemented')
+  },
+})
+
+export const uppercase = UppercaseExpression.builder
+
+export const SubstringExpression = defineExpression({
+  expressionKey: 'Substring',
+  builder: (string: Expression<string>, substring: Expression<string>) => {
+    return { string, substring }
+  },
+  resolver: (): boolean => {
+    throw new Error('Not yet implemented')
+  },
+})
+
+export const substring = SubstringExpression.builder

package/src/expression.ts

@@ -0,0 +1,48 @@
+import * as NumericExpressions from '@bessemer/cornerstone/expression/numeric-expression'
+import * as StringExpressions from '@bessemer/cornerstone/expression/string-expression'
+import * as ArrayExpressions from '@bessemer/cornerstone/expression/array-expression'
+import * as Expressions from '@bessemer/cornerstone/expression/expression'
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Signable } from '@bessemer/cornerstone/signature'
+import { UnknownRecord } from 'type-fest'
+
+export { Expressions, NumericExpressions, StringExpressions, ArrayExpressions }
+
+export type ExpressionKey<ReturnType, ArgumentType extends Array<unknown>> = NominalType<string, ['ExpressionKey', ReturnType, ArgumentType]>
+
+export type Expression<ReturnType> = ReturnType | IExpression<ReturnType>
+
+export interface IExpression<ReturnType> {
+  expressionKey: ExpressionKey<ReturnType, Array<unknown>>
+}
+
+export interface ExpressionReference<ReturnType, ArgumentType extends Array<unknown>> {
+  expressionKey: ExpressionKey<ReturnType, ArgumentType>
+}
+
+export interface ReducingExpression<ReturnType, ArgumentType> extends ExpressionReference<ReturnType, [Array<Expression<ArgumentType>>]> {}
+
+export type EvaluateExpression = <T>(expression: Expression<T>) => T
+
+export type ExpressionDefinition<
+  ReturnType,
+  ArgumentType extends Array<unknown>,
+  ExpressionType extends Expression<ReturnType>
+> = ExpressionReference<ReturnType, ArgumentType> & {
+  expressionKey: ExpressionKey<ReturnType, ArgumentType>
+  builder: (...parameters: ArgumentType) => ExpressionType
+  resolver: (expression: ExpressionType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType
+}
+
+export interface ExpressionVariable<T> extends IExpression<T> {
+  expressionKey: 'Variable'
+  name: string
+}
+
+export interface ParameterizedVariable<ValueType, ParameterType extends Array<Signable>> {
+  apply(...parameters: ParameterType): ExpressionVariable<ValueType>
+}
+
+export type ExpressionContext = {
+  variables: UnknownRecord
+}

package/src/function.ts

@@ -0,0 +1,3 @@
+import { isFunction as _isFunction } from 'lodash-es'
+
+export const isFunction = _isFunction

package/src/glob.ts

@@ -0,0 +1,19 @@
+import { minimatch } from 'minimatch'
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Zod } from '@bessemer/cornerstone'
+import { ZodType } from 'zod'
+
+export type GlobPattern = NominalType<string, 'GlobPattern'>
+export const GlobPatternSchema: ZodType<GlobPattern> = Zod.string()
+
+export const schema = (): ZodType<GlobPattern> => {
+  return Zod.string()
+}
+
+export const match = (str: string, pattern: GlobPattern): boolean => {
+  return minimatch(str, pattern)
+}
+
+export const anyMatch = (str: string, patterns: Array<GlobPattern>): boolean => {
+  return patterns.some((it) => match(str, it))
+}

package/src/global-variable.ts

@@ -0,0 +1,40 @@
+import { evaluate, LazyValue } from '@bessemer/cornerstone/lazy'
+import { isUndefined } from '@bessemer/cornerstone/object'
+import { UnknownRecord } from 'type-fest'
+
+export type GlobalVariable<T> = {
+  getValue: () => T
+  setValue: (value: T) => void
+}
+
+let Global: { BessemerGlobalVariables: UnknownRecord }
+if (typeof window !== 'undefined') {
+  Global = window as any
+} else if (typeof global !== 'undefined') {
+  Global = global as any
+} else {
+  Global = globalThis as any
+}
+
+if (isUndefined(Global.BessemerGlobalVariables)) {
+  Global.BessemerGlobalVariables = {}
+}
+
+export const createGlobalVariable = <T>(key: string, defaultValue: LazyValue<T>): GlobalVariable<T> => {
+  return {
+    getValue: () => {
+      const value = Global.BessemerGlobalVariables[key] as T | undefined
+
+      if (isUndefined(value)) {
+        const def = evaluate(defaultValue)
+        Global.BessemerGlobalVariables[key] = def
+        return def
+      }
+
+      return value
+    },
+    setValue: (value: T) => {
+      Global.BessemerGlobalVariables[key] = value
+    },
+  }
+}

package/src/hash.ts

@@ -0,0 +1,28 @@
+import { TaggedType } from '@bessemer/cornerstone/types'
+
+export type Hash = TaggedType<string, 'Hash'>
+
+export enum HashAlgorithm {
+  SHA1 = 'SHA-1',
+  SHA256 = 'SHA-256',
+}
+
+export const asString = (value: Hash): string => {
+  return value
+}
+
+export const insecureHash = async (message: string): Promise<Hash> => {
+  return hash(message, HashAlgorithm.SHA1)
+}
+
+export const secureHash = async (message: string): Promise<Hash> => {
+  return hash(message, HashAlgorithm.SHA256)
+}
+
+export const hash = async (message: string, algorithm: HashAlgorithm): Promise<Hash> => {
+  const msgBuffer = new TextEncoder().encode(message)
+  const hashBuffer = await crypto.subtle.digest(algorithm, msgBuffer)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+  return hashHex as Hash
+}

package/src/hex-code.ts

@@ -0,0 +1,6 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Zod } from '@bessemer/cornerstone/index'
+import { ZodType } from 'zod'
+
+export type HexCode = NominalType<string, 'HexCode'>
+export const HexCodeSchema: ZodType<HexCode> = Zod.string().length(7).startsWith('#').describe('A 6-digit hex code starting a # sign')

package/src/index.ts

@@ -0,0 +1,82 @@
+import * as Objects from '@bessemer/cornerstone/object'
+import * as Functions from '@bessemer/cornerstone/function'
+import * as Arrays from '@bessemer/cornerstone/array'
+import * as Strings from '@bessemer/cornerstone/string'
+import * as Async from '@bessemer/cornerstone/async'
+import * as Maths from '@bessemer/cornerstone/math'
+import * as Sets from '@bessemer/cornerstone/set'
+import * as Dates from '@bessemer/cornerstone/date'
+import * as Comparators from '@bessemer/cornerstone/comparator'
+import * as Equalitors from '@bessemer/cornerstone/equalitor'
+import * as Durations from '@bessemer/cornerstone/duration'
+import * as Uris from '@bessemer/cornerstone/uri'
+import * as Urls from '@bessemer/cornerstone/url'
+import * as Loggers from '@bessemer/cornerstone/logger'
+import * as Errors from '@bessemer/cornerstone/error'
+import * as ErrorEvents from '@bessemer/cornerstone/error-event'
+import * as Preconditions from '@bessemer/cornerstone/precondition'
+import * as Uuids from '@bessemer/cornerstone/uuid'
+import * as Ulids from '@bessemer/cornerstone/ulid'
+import * as Entries from '@bessemer/cornerstone/entry'
+import * as Hashes from '@bessemer/cornerstone/hash'
+import * as Crypto from '@bessemer/cornerstone/crypto'
+import * as Globs from '@bessemer/cornerstone/glob'
+
+import * as Zod from '@bessemer/cornerstone/zod'
+import * as Tags from '@bessemer/cornerstone/tag'
+import * as Promises from '@bessemer/cornerstone/promise'
+import * as References from '@bessemer/cornerstone/reference'
+import * as Signatures from '@bessemer/cornerstone/signature'
+import * as Eithers from '@bessemer/cornerstone/either'
+import * as Results from '@bessemer/cornerstone/result'
+import * as Lazy from '@bessemer/cornerstone/lazy'
+import * as Patches from '@bessemer/cornerstone/patch'
+import * as Content from '@bessemer/cornerstone/content'
+import * as Combinables from '@bessemer/cornerstone/combinable'
+import * as Properties from '@bessemer/cornerstone/property'
+import * as RichTexts from '@bessemer/cornerstone/rich-text'
+import * as Retry from '@bessemer/cornerstone/retry'
+import * as Stores from '@bessemer/cornerstone/store'
+import * as Misc from '@bessemer/cornerstone/misc'
+
+export {
+  Objects,
+  Functions,
+  Arrays,
+  Strings,
+  Async,
+  Maths,
+  Sets,
+  Dates,
+  Comparators,
+  Equalitors,
+  Durations,
+  Uris,
+  Urls,
+  Loggers,
+  Errors,
+  ErrorEvents,
+  Preconditions,
+  Uuids,
+  Ulids,
+  Entries,
+  Hashes,
+  Crypto,
+  Globs,
+  Zod,
+  Tags,
+  Promises,
+  References,
+  Signatures,
+  Eithers,
+  Results,
+  Lazy,
+  Patches,
+  Content,
+  Combinables,
+  Properties,
+  RichTexts,
+  Retry,
+  Stores,
+  Misc,
+}

package/src/lazy.ts

@@ -0,0 +1,11 @@
+import { Functions } from '@bessemer/cornerstone'
+
+export type LazyValue<T> = T | (() => T)
+
+export const evaluate = <T>(value: LazyValue<T>): T => {
+  if (Functions.isFunction(value)) {
+    return value()
+  } else {
+    return value
+  }
+}