@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-capture.8

package/src/GroupBy.ts

@@ -1,103 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as internal from "./internal/groupBy.js"
-import type { Pipeable } from "./Pipeable.js"
-import type { Predicate } from "./Predicate.js"
-import type * as Queue from "./Queue.js"
-import type * as Stream from "./Stream.js"
-import type * as Take from "./Take.js"
-import type { Covariant, NoInfer } from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const GroupByTypeId: unique symbol = internal.GroupByTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type GroupByTypeId = typeof GroupByTypeId
-
-/**
- * Representation of a grouped stream. This allows to filter which groups will
- * be processed. Once this is applied all groups will be processed in parallel
- * and the results will be merged in arbitrary order.
- *
- * @since 2.0.0
- * @category models
- */
-export interface GroupBy<out K, out V, out E = never, out R = never> extends GroupBy.Variance<K, V, E, R>, Pipeable {
-  readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace GroupBy {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<out K, out V, out E, out R> {
-    readonly [GroupByTypeId]: {
-      readonly _K: Covariant<K>
-      readonly _V: Covariant<V>
-      readonly _E: Covariant<E>
-      readonly _R: Covariant<R>
-    }
-  }
-}
-
-/**
- * Run the function across all groups, collecting the results in an
- * arbitrary order.
- *
- * @since 2.0.0
- * @category destructors
- */
-export const evaluate: {
-  <K, V, E, A, E2, R2>(
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
-  ): <R>(self: GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>
-  <K, V, E, R, A, E2, R2>(
-    self: GroupBy<K, V, E, R>,
-    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
-    options?: { readonly bufferSize?: number | undefined } | undefined
-  ): Stream.Stream<A, E | E2, R | R2>
-} = internal.evaluate
-
-/**
- * Filter the groups to be processed.
- *
- * @since 2.0.0
- * @category utils
- */
-export const filter: {
-  <K>(predicate: Predicate<NoInfer<K>>): <V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
-  <K, V, E, R>(self: GroupBy<K, V, E, R>, predicate: Predicate<K>): GroupBy<K, V, E, R>
-} = internal.filter
-
-/**
- * Only consider the first `n` groups found in the `Stream`.
- *
- * @since 2.0.0
- * @category utils
- */
-export const first: {
-  (n: number): <K, V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
-  <K, V, E, R>(self: GroupBy<K, V, E, R>, n: number): GroupBy<K, V, E, R>
-} = internal.first
-
-/**
- * Constructs a `GroupBy` from a `Stream`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const make: <K, V, E, R>(
-  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
-) => GroupBy<K, V, E, R> = internal.make

package/src/HKT.ts

@@ -1,45 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- */
-export declare const URI: unique symbol
-
-/**
- * @since 2.0.0
- */
-export interface TypeClass<F extends TypeLambda> {
-  readonly [URI]?: F
-}
-
-/**
- * @since 2.0.0
- */
-export interface TypeLambda {
-  readonly In: unknown
-  readonly Out2: unknown
-  readonly Out1: unknown
-  readonly Target: unknown
-}
-
-/**
- * @since 2.0.0
- */
-export type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
-  readonly type: unknown
-} ? (F & {
-    readonly In: In
-    readonly Out2: Out2
-    readonly Out1: Out1
-    readonly Target: Target
-  })["type"]
-  : {
-    readonly F: F
-    readonly In: Types.Contravariant<In>
-    readonly Out2: Types.Covariant<Out2>
-    readonly Out1: Types.Covariant<Out1>
-    readonly Target: Types.Invariant<Target>
-  }

package/src/Hash.ts

@@ -1,195 +0,0 @@
-/**
- * @since 2.0.0
- */
-import { pipe } from "./Function.js"
-import { globalValue } from "./GlobalValue.js"
-import { hasProperty } from "./Predicate.js"
-import { structuralRegionState } from "./Utils.js"
-
-/** @internal */
-const randomHashCache = globalValue(
-  Symbol.for("effect/Hash/randomHashCache"),
-  () => new WeakMap<object, number>()
-)
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const symbol: unique symbol = Symbol.for("effect/Hash")
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Hash {
-  [symbol](): number
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const hash: <A>(self: A) => number = <A>(self: A) => {
-  if (structuralRegionState.enabled === true) {
-    return 0
-  }
-
-  switch (typeof self) {
-    case "number":
-      return number(self)
-    case "bigint":
-      return string(self.toString(10))
-    case "boolean":
-      return string(String(self))
-    case "symbol":
-      return string(String(self))
-    case "string":
-      return string(self)
-    case "undefined":
-      return string("undefined")
-    case "function":
-    case "object": {
-      if (self === null) {
-        return string("null")
-      } else if (self instanceof Date) {
-        if (Number.isNaN(self.getTime())) {
-          return string("Invalid Date")
-        }
-        return hash(self.toISOString())
-      } else if (self instanceof URL) {
-        return hash(self.href)
-      } else if (isHash(self)) {
-        return self[symbol]()
-      } else {
-        return random(self)
-      }
-    }
-    default:
-      throw new Error(
-        `BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`
-      )
-  }
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const random: <A extends object>(self: A) => number = (self) => {
-  if (!randomHashCache.has(self)) {
-    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)))
-  }
-  return randomHashCache.get(self)!
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const combine: (b: number) => (self: number) => number = (b) => (self) => (self * 53) ^ b
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const optimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0x40000000)
-
-/**
- * @since 2.0.0
- * @category guards
- */
-export const isHash = (u: unknown): u is Hash => hasProperty(u, symbol)
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const number = (n: number) => {
-  if (n !== n || n === Infinity) {
-    return 0
-  }
-  let h = n | 0
-  if (h !== n) {
-    h ^= n * 0xffffffff
-  }
-  while (n > 0xffffffff) {
-    h ^= n /= 0xffffffff
-  }
-  return optimize(h)
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const string = (str: string) => {
-  let h = 5381, i = str.length
-  while (i) {
-    h = (h * 33) ^ str.charCodeAt(--i)
-  }
-  return optimize(h)
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const structureKeys = <A extends object>(o: A, keys: ReadonlyArray<keyof A>) => {
-  let h = 12289
-  for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]! as string), combine(hash((o as any)[keys[i]!])))
-  }
-  return optimize(h)
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const structure = <A extends object>(o: A) =>
-  structureKeys(o, Object.keys(o) as unknown as ReadonlyArray<keyof A>)
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const array = <A>(arr: ReadonlyArray<A>) => {
-  let h = 6151
-  for (let i = 0; i < arr.length; i++) {
-    h = pipe(h, combine(hash(arr[i])))
-  }
-  return optimize(h)
-}
-
-/**
- * @since 2.0.0
- * @category hashing
- */
-export const cached: {
-  (self: object): (hash: number) => number
-  (self: object, hash: number): number
-} = function() {
-  if (arguments.length === 1) {
-    const self = arguments[0] as object
-    return function(hash: number) {
-      Object.defineProperty(self, symbol, {
-        value() {
-          return hash
-        },
-        enumerable: false
-      })
-      return hash
-    } as any
-  }
-  const self = arguments[0] as object
-  const hash = arguments[1] as number
-  Object.defineProperty(self, symbol, {
-    value() {
-      return hash
-    },
-    enumerable: false
-  })
-
-  return hash
-}