Lorem Ipsum MCP Server

import * as Arr from "../Array.js" import type * as Effect from "../Effect.js" import * as Equal from "../Equal.js" import type * as FiberId from "../FiberId.js" import type * as FiberRef from "../FiberRef.js" import type * as FiberRefs from "../FiberRefs.js" import { dual, pipe } from "../Function.js" import * as HashSet from "../HashSet.js" import * as Option from "../Option.js" import { pipeArguments } from "../Pipeable.js" import * as core from "./core.js" /** @internal */ export function unsafeMake( fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>> ): FiberRefs.FiberRefs { return new FiberRefsImpl(fiberRefLocals) } /** @internal */ export function empty(): FiberRefs.FiberRefs { return unsafeMake(new Map()) } /** @internal */ export const FiberRefsSym: FiberRefs.FiberRefsSym = Symbol.for("effect/FiberRefs") as FiberRefs.FiberRefsSym /** @internal */ export class FiberRefsImpl implements FiberRefs.FiberRefs { readonly [FiberRefsSym]: FiberRefs.FiberRefsSym = FiberRefsSym constructor( readonly locals: Map< FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]> > ) {} pipe() { return pipeArguments(this, arguments) } } /** @internal */ const findAncestor = ( _ref: FiberRef.FiberRef<any>, _parentStack: ReadonlyArray<readonly [FiberId.Single, unknown]>, _childStack: ReadonlyArray<readonly [FiberId.Single, unknown]>, _childModified = false ): readonly [unknown, boolean] => { const ref = _ref let parentStack = _parentStack let childStack = _childStack let childModified = _childModified let ret: readonly [unknown, boolean] | undefined = undefined while (ret === undefined) { if (Arr.isNonEmptyReadonlyArray(parentStack) && Arr.isNonEmptyReadonlyArray(childStack)) { const parentFiberId = Arr.headNonEmpty(parentStack)[0] const parentAncestors = Arr.tailNonEmpty(parentStack) const childFiberId = Arr.headNonEmpty(childStack)[0] const childRefValue = Arr.headNonEmpty(childStack)[1] const childAncestors = Arr.tailNonEmpty(childStack) if (parentFiberId.startTimeMillis < childFiberId.startTimeMillis) { childStack = childAncestors childModified = true } else if (parentFiberId.startTimeMillis > childFiberId.startTimeMillis) { parentStack = parentAncestors } else { if (parentFiberId.id < childFiberId.id) { childStack = childAncestors childModified = true } else if (parentFiberId.id > childFiberId.id) { parentStack = parentAncestors } else { ret = [childRefValue, childModified] as const } } } else { ret = [ref.initial, true] as const } } return ret } /** @internal */ export const joinAs = dual< (fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs, (self: FiberRefs.FiberRefs, fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => FiberRefs.FiberRefs >(3, (self, fiberId, that) => { const parentFiberRefs = new Map(self.locals) that.locals.forEach((childStack, fiberRef) => { const childValue = childStack[0][1] if (!childStack[0][0][Equal.symbol](fiberId)) { if (!parentFiberRefs.has(fiberRef)) { if (Equal.equals(childValue, fiberRef.initial)) { return } parentFiberRefs.set( fiberRef, [[fiberId, fiberRef.join(fiberRef.initial, childValue)]] ) return } const parentStack = parentFiberRefs.get(fiberRef)! const [ancestor, wasModified] = findAncestor( fiberRef, parentStack, childStack ) if (wasModified) { const patch = fiberRef.diff(ancestor, childValue) const oldValue = parentStack[0][1] const newValue = fiberRef.join(oldValue, fiberRef.patch(patch)(oldValue)) if (!Equal.equals(oldValue, newValue)) { let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]> const parentFiberId = parentStack[0][0] if (parentFiberId[Equal.symbol](fiberId)) { newStack = [[parentFiberId, newValue] as const, ...parentStack.slice(1)] } else { newStack = [[fiberId, newValue] as const, ...parentStack] } parentFiberRefs.set(fiberRef, newStack) } } } }) return new FiberRefsImpl(parentFiberRefs) }) /** @internal */ export const forkAs = dual< (childId: FiberId.Single) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs, (self: FiberRefs.FiberRefs, childId: FiberId.Single) => FiberRefs.FiberRefs >(2, (self, childId) => { const map = new Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]>>() unsafeForkAs(self, map, childId) return new FiberRefsImpl(map) }) const unsafeForkAs = ( self: FiberRefs.FiberRefs, map: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>, fiberId: FiberId.Single ) => { self.locals.forEach((stack, fiberRef) => { const oldValue = stack[0][1] const newValue = fiberRef.patch(fiberRef.fork)(oldValue) if (Equal.equals(oldValue, newValue)) { map.set(fiberRef, stack) } else { map.set(fiberRef, [[fiberId, newValue] as const, ...stack]) } }) } /** @internal */ export const fiberRefs = (self: FiberRefs.FiberRefs) => HashSet.fromIterable(self.locals.keys()) /** @internal */ export const setAll = (self: FiberRefs.FiberRefs): Effect.Effect<void> => core.forEachSequentialDiscard( fiberRefs(self), (fiberRef) => core.fiberRefSet(fiberRef, getOrDefault(self, fiberRef)) ) /** @internal */ export const delete_ = dual< <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs, <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => FiberRefs.FiberRefs >(2, (self, fiberRef) => { const locals = new Map(self.locals) locals.delete(fiberRef) return new FiberRefsImpl(locals) }) /** @internal */ export const get = dual< <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => Option.Option<A>, <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => Option.Option<A> >(2, (self, fiberRef) => { if (!self.locals.has(fiberRef)) { return Option.none() } return Option.some(Arr.headNonEmpty(self.locals.get(fiberRef)!)[1]) }) /** @internal */ export const getOrDefault = dual< <A>(fiberRef: FiberRef.FiberRef<A>) => (self: FiberRefs.FiberRefs) => A, <A>(self: FiberRefs.FiberRefs, fiberRef: FiberRef.FiberRef<A>) => A >(2, (self, fiberRef) => pipe(get(self, fiberRef), Option.getOrElse(() => fiberRef.initial))) /** @internal */ export const updateAs = dual< <A>( options: { readonly fiberId: FiberId.Single readonly fiberRef: FiberRef.FiberRef<A> readonly value: A } ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs, <A>( self: FiberRefs.FiberRefs, options: { readonly fiberId: FiberId.Single readonly fiberRef: FiberRef.FiberRef<A> readonly value: A } ) => FiberRefs.FiberRefs >(2, <A>(self: FiberRefs.FiberRefs, { fiberId, fiberRef, value }: { readonly fiberId: FiberId.Single readonly fiberRef: FiberRef.FiberRef<A> readonly value: A }) => { if (self.locals.size === 0) { return new FiberRefsImpl(new Map([[fiberRef, [[fiberId, value] as const]]])) } const locals = new Map(self.locals) unsafeUpdateAs(locals, fiberId, fiberRef, value) return new FiberRefsImpl(locals) }) const unsafeUpdateAs = ( locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>, fiberId: FiberId.Single, fiberRef: FiberRef.FiberRef<any>, value: any ) => { const oldStack: ReadonlyArray<readonly [FiberId.Single, any]> = locals.get(fiberRef) ?? [] let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]> | undefined if (Arr.isNonEmptyReadonlyArray(oldStack)) { const [currentId, currentValue] = Arr.headNonEmpty(oldStack) if (currentId[Equal.symbol](fiberId)) { if (Equal.equals(currentValue, value)) { return } else { newStack = [ [fiberId, value] as const, ...oldStack.slice(1) ] } } else { newStack = [ [fiberId, value] as const, ...oldStack ] } } else { newStack = [[fiberId, value] as const] } locals.set(fiberRef, newStack) } /** @internal */ export const updateManyAs = dual< ( options: { readonly forkAs?: FiberId.Single | undefined readonly entries: Arr.NonEmptyReadonlyArray< readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>] > } ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs, ( self: FiberRefs.FiberRefs, options: { readonly forkAs?: FiberId.Single | undefined readonly entries: Arr.NonEmptyReadonlyArray< readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>] > } ) => FiberRefs.FiberRefs >(2, (self: FiberRefs.FiberRefs, { entries, forkAs }: { readonly forkAs?: FiberId.Single | undefined readonly entries: Arr.NonEmptyReadonlyArray< readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>] > }) => { if (self.locals.size === 0) { return new FiberRefsImpl(new Map(entries)) } const locals = new Map(self.locals) if (forkAs !== undefined) { unsafeForkAs(self, locals, forkAs) } entries.forEach(([fiberRef, values]) => { if (values.length === 1) { unsafeUpdateAs(locals, values[0][0], fiberRef, values[0][1]) } else { values.forEach(([fiberId, value]) => { unsafeUpdateAs(locals, fiberId, fiberRef, value) }) } }) return new FiberRefsImpl(locals) })