@bessemer/cornerstone 0.5.0

package/src/property.ts

@@ -0,0 +1,29 @@
+import { Objects, Tags } from '@bessemer/cornerstone'
+import { SerializedTags, Tag, TaggedValue } from '@bessemer/cornerstone/tag'
+import { UnknownRecord } from 'type-fest'
+import { DeepPartial } from '@bessemer/cornerstone/types'
+
+export type PropertyRecord<T extends UnknownRecord> = {
+  values: T
+  overrides: Record<SerializedTags, PropertyOverride<T>>
+}
+
+export type PropertyOverride<T> = TaggedValue<DeepPartial<T>>
+
+export const properties = <T extends UnknownRecord>(values: T, overrides?: Array<PropertyOverride<T>>): PropertyRecord<T> => {
+  const propertyOverrideEntries = (overrides ?? []).map((override) => {
+    return [Tags.serializeTags(override.tags), override]
+  })
+
+  const propertyOverrides: Record<SerializedTags, PropertyOverride<T>> = Object.fromEntries(propertyOverrideEntries)
+
+  return {
+    values,
+    overrides: propertyOverrides,
+  }
+}
+
+export const resolve = <T extends UnknownRecord>(properties: PropertyRecord<T>, tags: Array<Tag>): T => {
+  const overrides = Tags.resolve(Object.values(properties.overrides), tags)
+  return Objects.mergeAll([properties.values, ...overrides.reverse()]) as T
+}

package/src/reference.ts

@@ -0,0 +1,68 @@
+import { Comparators, Equalitors, Objects, Strings } from '@bessemer/cornerstone'
+import { Comparator } from '@bessemer/cornerstone/comparator'
+import { NominalType } from '@bessemer/cornerstone/types'
+
+export type ReferenceId<T extends string> = NominalType<string, ['ReferenceId', T]>
+
+export type Reference<T extends string> = {
+  id: ReferenceId<T>
+  type: T
+  note?: string
+}
+
+export type ReferenceType<T extends Reference<string>> = T | T['id']
+
+export interface Referencable<T extends Reference<string>> {
+  reference: T
+}
+
+export type ReferencableType<T extends Reference<string>> = T | Referencable<T>
+
+export const reference = <T extends string>(reference: Reference<T> | ReferenceId<T>, type: T, note?: string): Reference<typeof type> => {
+  if (!Strings.isString(reference)) {
+    return reference
+  }
+
+  return {
+    id: reference,
+    type,
+    ...(Objects.isPresent(note) ? { note: note } : {}),
+  }
+}
+
+export const isReferencable = (element: unknown): element is Referencable<Reference<string>> => {
+  if (!Objects.isObject(element)) {
+    return false
+  }
+
+  const referencable = element as Referencable<Reference<string>>
+  return !Objects.isUndefined(referencable.reference)
+}
+
+export const isReference = (element: unknown): element is Reference<string> => {
+  if (!Objects.isObject(element)) {
+    return false
+  }
+
+  const referencable = element as Reference<string>
+  return !Objects.isUndefined(referencable.id) && !Objects.isUndefined(referencable.type) && !Objects.isUndefined(referencable.note)
+}
+
+export const getReference = <T extends Reference<string>>(reference: ReferencableType<T>): T => {
+  const referencable = reference as Referencable<T>
+  if (Objects.isPresent(referencable.reference)) {
+    return referencable.reference
+  } else {
+    return reference as T
+  }
+}
+
+export const equals = <T extends string>(first: Reference<T>, second: Reference<T>): boolean => {
+  return first.id === second.id
+}
+
+export const comparator = <T extends string>(): Comparator<Reference<T>> => {
+  return Comparators.compareBy((it) => it.id, Comparators.natural())
+}
+
+export const equalitor = () => Equalitors.fromComparator(comparator())

package/src/resource.ts

@@ -0,0 +1,32 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Strings, Zod } from '@bessemer/cornerstone/index'
+import { ZodType } from 'zod'
+
+export type ResourceKey = string
+
+export type ResourceNamespace = NominalType<string, 'ResourceNamespace'>
+export const ResourceNamespaceSchema: ZodType<ResourceNamespace> = Zod.string()
+
+export namespace ResourceKey {
+  const ResourceNamespaceSeparator = '/'
+
+  export const namespace = (namespace: ResourceNamespace, key: ResourceKey): ResourceKey => {
+    return `${namespace}${ResourceNamespaceSeparator}${key}`
+  }
+
+  export const namespaceAll = (namespace: ResourceNamespace, keys: Array<ResourceKey>): Array<ResourceKey> => {
+    return keys.map((it) => ResourceKey.namespace(namespace, it))
+  }
+
+  export const stripNamespace = (namespace: ResourceNamespace, key: ResourceKey): ResourceKey => {
+    return Strings.removeStart(key, `${namespace}${ResourceNamespaceSeparator}`)
+  }
+
+  export const stripNamespaceAll = (namespace: ResourceNamespace, keys: Array<ResourceKey>): Array<ResourceKey> => {
+    return keys.map((it) => ResourceKey.stripNamespace(namespace, it))
+  }
+
+  export const extendNamespace = (...namespaces: Array<ResourceNamespace>): ResourceNamespace => {
+    return namespaces.join(ResourceNamespaceSeparator)
+  }
+}

package/src/result.ts

@@ -0,0 +1,66 @@
+import { Left, Right } from '@bessemer/cornerstone/either'
+import { Eithers, Promises } from '@bessemer/cornerstone'
+import { Throwable } from '@bessemer/cornerstone/types'
+
+export type Success<T> = Right<T> & {
+  isSuccess: true
+}
+
+export type Failure = Left<Throwable | null> & {
+  isSuccess: false
+}
+
+export type Result<T> = Success<T> | Failure
+export type AsyncResult<T> = Promise<Result<T>>
+
+export const success = <T>(value: T): Success<T> => {
+  return { ...Eithers.right(value), isSuccess: true }
+}
+
+export const failure = (failure?: Throwable): Failure => {
+  return { ...Eithers.left(failure ?? null), isSuccess: false }
+}
+
+export function tryValue<SOURCE_VALUE>(resolver: () => Promise<SOURCE_VALUE>): AsyncResult<SOURCE_VALUE>
+export function tryValue<SOURCE_VALUE>(resolver: () => SOURCE_VALUE): Result<SOURCE_VALUE>
+export function tryValue<SOURCE_VALUE>(resolver: () => SOURCE_VALUE | Promise<SOURCE_VALUE>): Result<SOURCE_VALUE> | Promise<Result<SOURCE_VALUE>> {
+  try {
+    let result = resolver()
+    if (Promises.isPromise(result)) {
+      return result.then((it) => success(it)).catch((it) => failure(it))
+    } else {
+      return success(result)
+    }
+  } catch (e: any) {
+    return failure(e)
+  }
+}
+
+export function tryResult<SOURCE_VALUE>(resolver: () => Result<SOURCE_VALUE>): Result<SOURCE_VALUE>
+export function tryResult<SOURCE_VALUE>(resolver: () => AsyncResult<SOURCE_VALUE>): AsyncResult<SOURCE_VALUE>
+export function tryResult<SOURCE_VALUE>(resolver: () => Result<SOURCE_VALUE> | AsyncResult<SOURCE_VALUE>): ReturnType<typeof resolver> {
+  try {
+    let result = resolver()
+    if (Promises.isPromise(result)) {
+      return result.catch((it) => failure(it))
+    } else {
+      return result
+    }
+  } catch (e: any) {
+    return failure(e)
+  }
+}
+
+export function map<SOURCE_VALUE, TARGET_VALUE>(
+  result: Result<SOURCE_VALUE>,
+  valueMapper: (element: SOURCE_VALUE) => TARGET_VALUE
+): Result<TARGET_VALUE> {
+  if (result.isSuccess) {
+    return {
+      ...result,
+      value: valueMapper(result.value),
+    }
+  } else {
+    return result
+  }
+}

package/src/retry.ts

@@ -0,0 +1,70 @@
+import { Duration } from '@bessemer/cornerstone/duration'
+import { Async, Durations, Maths, Objects, Preconditions, Results } from '@bessemer/cornerstone/index'
+import { AsyncResult, Result } from '@bessemer/cornerstone/result'
+import { PartialDeep } from 'type-fest'
+
+export type RetryProps = {
+  attempts: number
+  delay: Duration
+}
+
+export type RetryOptions = PartialDeep<RetryProps>
+
+export const None: RetryProps = {
+  attempts: 0,
+  delay: Durations.Zero,
+}
+
+export const DefaultRetryProps: RetryProps = {
+  attempts: 3,
+  delay: Durations.ofMilliseconds(500),
+}
+
+export type RetryState = {
+  attempt: number
+  props: RetryProps
+}
+
+export const initialize = (initialOptions?: RetryOptions): RetryState => {
+  const props = Objects.merge(DefaultRetryProps, initialOptions)
+  Preconditions.isTrue(props.attempts >= 0, () => 'usingRetry attempts must be >= 0')
+
+  return {
+    attempt: 0,
+    props,
+  }
+}
+
+export const retry = async (state: RetryState): Promise<RetryState | undefined> => {
+  if (state.attempt >= state.props.attempts - 1) {
+    return undefined
+  }
+
+  const delayMs = Durations.inMilliseconds(state.props.delay)
+  const maxJitterMs = delayMs * 0.3 // We calculate max jitter as 30% of the delay
+  await Async.sleep(Durations.ofMilliseconds(delayMs + Maths.random(0, maxJitterMs)))
+
+  return {
+    props: state.props,
+    attempt: state.attempt + 1,
+  }
+}
+
+export const usingRetry = async <T>(runnable: () => Promise<Result<T>>, initialOptions?: RetryOptions): AsyncResult<T> => {
+  let retryState: RetryState | undefined = initialize(initialOptions)
+  let previousResult: Result<T> = Results.failure()
+
+  do {
+    // JOHN Should this be a try/catch? it was causing debugging problems
+    const result = await runnable()
+    previousResult = result
+
+    if (result.isSuccess) {
+      return result
+    }
+
+    retryState = await retry(retryState)
+  } while (!Objects.isUndefined(retryState))
+
+  return previousResult
+}

package/src/rich-text.ts

@@ -0,0 +1,24 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Objects } from '@bessemer/cornerstone'
+
+// These are to match TipTap types, but without us having to depend on the TipTap library
+export type RichTextJson = {
+  type?: string
+  attrs?: Record<string, any>
+  content?: RichTextJson[]
+  marks?: {
+    type: string
+    attrs?: Record<string, any>
+    [key: string]: any
+  }[]
+  text?: string
+  [key: string]: any
+}
+
+export type RichTextString = NominalType<string, 'RichTextString'>
+
+export type RichText = RichTextString | RichTextJson
+
+export const isJson = (text: RichText): text is RichTextJson => {
+  return Objects.isObject(text)
+}

package/src/set.ts

@@ -0,0 +1,46 @@
+export const cartesianProduct = <T>(...arrays: Array<Array<T>>): Array<Array<T>> => {
+  return arrays.reduce<Array<Array<T>>>((acc, array) => acc.flatMap((product) => array.map((element) => [...product, element])), [[]])
+}
+
+export const permute = <T>(values: Array<T>): Array<Array<T>> => {
+  let result: Array<Array<T>> = []
+
+  const permuteInternal = (arr: Array<T>, m: Array<T> = []) => {
+    if (arr.length === 0) {
+      result.push(m)
+    } else {
+      for (let i = 0; i < arr.length; i++) {
+        let curr = arr.slice()
+        let next = curr.splice(i, 1)
+        permuteInternal(curr.slice(), m.concat(next))
+      }
+    }
+  }
+
+  permuteInternal(values)
+  return result
+}
+
+export const properPowerSet = <T>(values: Array<T>): Array<Array<T>> => {
+  const powerSet: Array<Array<T>> = []
+
+  const totalSubsets = 1 << values.length // 2^n, where n is the size of the set
+
+  for (let i = 1; i < totalSubsets; i++) {
+    // Start from 1 to exclude the empty set
+    const subset: T[] = []
+    for (let j = 0; j < values.length; j++) {
+      if (i & (1 << j)) {
+        // Check if the j-th element is in the subset
+        subset.push(values[j]!)
+      }
+    }
+    powerSet.push(subset)
+  }
+
+  return powerSet
+}
+
+export const powerSet = <T>(values: Array<T>): Array<Array<T>> => {
+  return [[], ...properPowerSet(values)]
+}

package/src/signature.ts

@@ -0,0 +1,20 @@
+import { Objects, References } from '@bessemer/cornerstone'
+import { Reference } from '@bessemer/cornerstone/reference'
+
+export type Signable = number | string | { id: string } | { reference: Reference<string> }
+
+export const sign = (value: Signable): string | number => {
+  if (Objects.isObject(value)) {
+    if (References.isReferencable(value)) {
+      return value.reference.id
+    } else {
+      return value.id
+    }
+  }
+
+  return value
+}
+
+export const signAll = (values: Array<Signable>): Array<string | number> => {
+  return values.map(sign)
+}

package/src/store.ts

@@ -0,0 +1,91 @@
+import { ResourceKey } from '@bessemer/cornerstone/resource'
+import { Entry } from '@bessemer/cornerstone/entry'
+import { Arrays, Entries, Objects } from '@bessemer/cornerstone/index'
+
+export interface LocalStore<T> {
+  setValue: (value: T | undefined) => void
+  getValue: () => T | undefined
+}
+
+export interface LocalKeyValueStore<T> {
+  setValues: (entries: Array<Entry<T | undefined>>) => void
+  setValue: (key: ResourceKey, value: T | undefined) => void
+
+  getEntries: () => Array<Entry<T>>
+  getValues: (keys: Array<ResourceKey>) => Array<Entry<T>>
+  getValue: (key: ResourceKey) => T | undefined
+}
+
+export interface RemoteStore<T> {
+  writeValue: (value: T | undefined) => Promise<void>
+  fetchValue: () => Promise<T | undefined>
+}
+
+export interface RemoteKeyValueStore<T> {
+  writeValues: (entries: Array<Entry<T | undefined>>) => Promise<void>
+  writeValue: (key: ResourceKey, value: T | undefined) => Promise<void>
+
+  fetchValues: (keys: Array<ResourceKey>) => Promise<Array<Entry<T>>>
+  fetchValue: (key: ResourceKey) => Promise<T | undefined>
+}
+
+export abstract class AbstractRemoteKeyValueStore<T> implements RemoteKeyValueStore<T> {
+  abstract writeValues: (entries: Array<Entry<T | undefined>>) => Promise<void>
+
+  writeValue = async (key: ResourceKey, value: T | undefined): Promise<void> => {
+    await this.writeValues([Entries.of(key, value)])
+  }
+
+  abstract fetchValues: (keys: Array<ResourceKey>) => Promise<Array<Entry<T>>>
+
+  fetchValue = async (key: ResourceKey): Promise<T | undefined> => {
+    return Arrays.first(await this.fetchValues([key]))?.[1]
+  }
+}
+
+export abstract class AbstractLocalKeyValueStore<T> extends AbstractRemoteKeyValueStore<T> implements LocalKeyValueStore<T> {
+  abstract setValues: (entries: Array<Entry<T | undefined>>) => void
+
+  setValue = (key: ResourceKey, value: T | undefined): void => {
+    this.setValues([Entries.of(key, value)])
+  }
+
+  abstract getEntries: () => Array<Entry<T>>
+  abstract getValues: (keys: Array<ResourceKey>) => Array<Entry<T>>
+
+  getValue = (key: ResourceKey): T | undefined => {
+    return Arrays.first(this.getValues([key]))?.[1]
+  }
+
+  fetchValues = async (keys: Array<ResourceKey>): Promise<Array<Entry<T>>> => {
+    return this.getValues(keys)
+  }
+
+  writeValues = async (entries: Array<Entry<T | undefined>>): Promise<void> => {
+    this.setValues(entries)
+  }
+}
+
+export const fromMap = <T>(): LocalKeyValueStore<T> => {
+  const map = new Map<string, T>()
+
+  return new (class extends AbstractLocalKeyValueStore<T> {
+    override getEntries = (): Array<Entry<T>> => {
+      return Array.from(map.entries())
+    }
+
+    override setValues = (entries: Entry<T | undefined>[]): void => {
+      entries.forEach(([key, value]) => {
+        if (Objects.isNil(value)) {
+          map.delete(key)
+        } else {
+          map.set(key, value)
+        }
+      })
+    }
+
+    override getValues = (keys: Array<ResourceKey>): Array<Entry<T>> => {
+      return keys.map((key) => Entries.of(key, map.get(key)!)).filter((it) => Objects.isPresent(it[1]))
+    }
+  })()
+}

package/src/string.ts

@@ -0,0 +1,173 @@
+import {
+  endsWith as _endsWith,
+  includes as _includes,
+  isEmpty as _isEmpty,
+  isString as _isString,
+  padEnd as _padEnd,
+  padStart as _padStart,
+  replace as _replace,
+  startsWith as _startsWith,
+} from 'lodash-es'
+import { Arrays } from '@bessemer/cornerstone'
+import { UnknownRecord } from 'type-fest'
+
+export const isString = (value?: any): value is string => {
+  return _isString(value)
+}
+
+export const isEmpty = _isEmpty
+
+export type StringSplitResult = { selection: string; separator: string; rest: string } | { selection: null; separator: null; rest: string }
+
+export const splitFirst = (str: string, splitter: string | RegExp): StringSplitResult => {
+  if (isString(splitter)) {
+    const results = str.split(splitter)
+    if (results.length === 1) {
+      return { selection: null, separator: null, rest: str }
+    }
+
+    return { selection: results[0]!, separator: splitter, rest: Arrays.rest(results).join(splitter) }
+  } else {
+    const match = splitter.exec(str)
+
+    if (!match) {
+      return { selection: null, separator: null, rest: str }
+    }
+
+    const matchIndex = match.index
+    const beforeMatch = str.slice(0, matchIndex)
+    const afterMatch = str.slice(matchIndex + match[0].length)
+    const separator = match[0]
+    return { selection: beforeMatch, separator, rest: afterMatch }
+  }
+}
+
+export const splitLast = (str: string, splitter: string | RegExp): StringSplitResult => {
+  if (isString(splitter)) {
+    const results = str.split(splitter)
+    if (results.length === 1) {
+      return { selection: null, separator: null, rest: str }
+    }
+
+    return { selection: results[results.length - 1]!, separator: splitter, rest: results.slice(0, results.length - 1).join(splitter) }
+  } else {
+    if (!splitter.global) {
+      splitter = new RegExp(splitter.source, splitter.flags + 'g')
+    }
+
+    const matches = Array.from(str.matchAll(splitter))
+
+    if (matches.length === 0) {
+      return { selection: null, separator: null, rest: str }
+    }
+
+    // Use the last match
+    const lastMatch = matches[matches.length - 1]!
+    const matchIndex = lastMatch.index!
+    const separator = lastMatch[0]!
+    const beforeMatch = str.slice(0, matchIndex)
+    const afterMatch = str.slice(matchIndex + separator.length)
+
+    return {
+      selection: afterMatch,
+      separator: separator,
+      rest: beforeMatch,
+    }
+  }
+}
+
+export const splitLastRegex = (str: string, regex: RegExp): StringSplitResult => {
+  // Find the last match using regex lastIndex
+  let lastMatch: RegExpExecArray | null = null
+  let match
+
+  while ((match = regex.exec(str)) !== null) {
+    lastMatch = match
+  }
+
+  if (!lastMatch) {
+    return { selection: null, separator: null, rest: str }
+  }
+
+  const matchIndex = lastMatch.index!
+  const separator = lastMatch[0]
+  const beforeMatch = str.slice(0, matchIndex)
+  const afterMatch = str.slice(matchIndex + separator.length)
+
+  return {
+    selection: afterMatch,
+    separator,
+    rest: beforeMatch,
+  }
+}
+
+export const splitAt = (str: string, index: number): [string, string] => {
+  return [str.slice(0, index), str.slice(index)] as const
+}
+
+export const startsWith = _startsWith
+export const endsWith = _endsWith
+
+export const removeStart = (string: string, substring: string): string => {
+  if (!string.startsWith(substring)) {
+    return string
+  }
+
+  return string.slice(substring.length)
+}
+
+export const removeEnd = (string: string, substring: string): string => {
+  if (!string.endsWith(substring)) {
+    return string
+  }
+
+  return string.slice(0, -substring.length)
+}
+
+export const isBlank = (str?: string | null): boolean => {
+  const testStr = str ?? ''
+  return /^\s*$/.test(testStr)
+}
+
+export const mostCentralOccurrence = (str: string, substr: string): number | null => {
+  const occurrences: number[] = []
+  let index = str.indexOf(substr)
+
+  while (index !== -1) {
+    occurrences.push(index)
+    index = str.indexOf(substr, index + 1)
+  }
+
+  if (occurrences.length === 0) {
+    return null
+  }
+
+  const center = str.length / 2
+
+  let closestIndex = occurrences[0]!
+  let minDistance = Math.abs(center - closestIndex)
+
+  for (let i = 1; i < occurrences.length; i++) {
+    const distance = Math.abs(center - occurrences[i]!)
+    if (distance < minDistance) {
+      minDistance = distance
+      closestIndex = occurrences[i]!
+    }
+  }
+
+  return closestIndex
+}
+
+export const replacePlaceholders = (string: string, parameters: UnknownRecord, getParamPlaceholder = (paramName: string) => `{{${paramName}}}`) => {
+  return Object.entries(parameters).reduce(
+    (intermediateString, [paramName, paramValue]) => intermediateString.replaceAll(getParamPlaceholder(paramName), `${paramValue}`),
+    string
+  )
+}
+
+export const padStart = _padStart
+export const padEnd = _padEnd
+
+export const contains = _includes
+
+export const replace = _replace

package/src/tag.ts

@@ -0,0 +1,68 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Comparator } from '@bessemer/cornerstone/comparator'
+import { Arrays, Comparators, Equalitors, Sets } from '@bessemer/cornerstone'
+import { Equalitor } from '@bessemer/cornerstone/equalitor'
+
+export type TagType<DataType> = NominalType<string, ['TagType', DataType]>
+
+export type Tag<DataType = unknown> = {
+  type: TagType<DataType>
+  value: DataType
+}
+
+export type TaggedValue<T> = {
+  value: T
+  tags: Array<Tag>
+}
+
+export const tag = <T>(type: TagType<T>, value: T): Tag<T> => {
+  return {
+    type,
+    value,
+  }
+}
+
+export const value = <T>(value: T, tags: Array<Tag>) => {
+  return {
+    value,
+    tags: Arrays.sortWith(tags, tagComparator()),
+  }
+}
+
+export const tagComparator = <T>(): Comparator<Tag<T>> => {
+  return Comparators.aggregate([
+    Comparators.compareBy((it) => it.type, Comparators.natural()),
+    Comparators.compareBy((it) => JSON.stringify(it.value), Comparators.natural()),
+  ])
+}
+
+export const tagEqualitor = <T>(): Equalitor<Tag<T>> => {
+  return Equalitors.fromComparator(tagComparator())
+}
+
+export type SerializedTags = NominalType<string, 'SerializedTags'>
+
+export const serializeTags = <T>(tags: Array<Tag<T>>): SerializedTags => {
+  const serializedTags: SerializedTags = Arrays.sortWith(tags, tagComparator())
+    .map(({ type, value }) => `${type}:${JSON.stringify(value)}`)
+    .join('.')
+
+  return serializedTags
+}
+
+export const resolve = <T>(values: Array<TaggedValue<T>>, tags: Array<Tag>): Array<TaggedValue<T>> => {
+  return resolveBy(values, (it) => it.tags, tags)
+}
+
+export const resolveBy = <T>(values: Array<T>, mapper: (value: T) => Array<Tag>, tags: Array<Tag>): Array<T> => {
+  const resolvedValues = Sets.properPowerSet(tags).flatMap((tags) => {
+    return values.filter((it) => Arrays.equalWith(mapper(it), tags, tagEqualitor()))
+  })
+
+  if (Arrays.isEmpty(resolvedValues)) {
+    const defaultValues = values.filter((it) => Arrays.isEmpty(mapper(it)))
+    return defaultValues
+  }
+
+  return resolvedValues.reverse()
+}