@typed/fx 0.0.35 → 1.0.2

package/src/zip.ts

@@ -1,70 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-export function zip<R2, E2, B>(second: Fx<R2, E2, B>) {
-  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
-    zipAll([first, second])
-}
-
-export function zipAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fx: readonly [...FX],
-): Fx<
-  Fx.ResourcesOf<FX[number]>,
-  Fx.ErrorsOf<FX[number]>,
-  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> }
->
-
-export function zipAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>>
-
-export function zipAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>> {
-  return Fx((emitter) =>
-    Effect.suspendSucceed(() => {
-      const array = Array.from(iterable)
-
-      if (array.length === 0) {
-        return pipe(emitter.emit([]), Effect.zipRight(emitter.end))
-      }
-
-      return pipe(
-        Effect.sync<Maybe.Maybe<A>[]>(() => Array(array.length)),
-        Effect.flatMap((ref) =>
-          Effect.suspendSucceed(() => {
-            const emitIfReady = pipe(
-              Effect.sync(() => ref.filter(Maybe.isSome).map((x) => x.value)),
-              Effect.flatMap((bs) =>
-                bs.length === array.length
-                  ? Effect.suspendSucceed(() => (ref.fill(Maybe.none), emitter.emit(bs)))
-                  : Effect.unit,
-              ),
-            )
-
-            return withDynamicCountdownLatch(
-              array.length,
-              ({ latch }) =>
-                Effect.forEachWithIndex(array, (push, i) =>
-                  Effect.forkScoped(
-                    push.run(
-                      Emitter(
-                        (a) =>
-                          pipe(
-                            Effect.sync(() => (ref[i] = Maybe.some(a))),
-                            Effect.zipRight(emitIfReady),
-                          ),
-                        emitter.failCause,
-                        latch.countDown,
-                      ),
-                    ),
-                  ),
-                ),
-              emitter.end,
-            )
-          }),
-        ),
-      )
-    }),
-  )
-}

package/src/zipIterable.test.ts

@@ -1,19 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.withIterable.name, () => {
-    it('zips fx with an iterable', async () => {
-      const values = [1, 2, 3]
-      const test = pipe(Fx.periodic(Duration.millis(10)), Fx.withIterable(values))
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, values)
-    })
-  })
-})

package/src/zipIterable.ts

@@ -1,51 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { identity, pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { exitEarly, onEarlyExitFailure } from './_internal.js'
-
-export function zipIterable<A, B, C>(iterable: Iterable<A>, f: (a: A, b: B) => C) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => zipIterable_(fx, iterable, f)
-}
-
-export function withIterable<A>(iterable: Iterable<A>) {
-  return <R, E, B>(fx: Fx<R, E, B>): Fx<R, E, A> => zipIterable_(fx, iterable, identity)
-}
-
-function zipIterable_<R, E, A, B, C>(
-  fx: Fx<R, E, B>,
-  iterable: Iterable<A>,
-  f: (a: A, b: B) => C,
-): Fx<R, E, C> {
-  return Fx((emitter) =>
-    pipe(
-      Effect.suspendSucceed(() => {
-        const iterator = iterable[Symbol.iterator]()
-        let result = iterator.next()
-
-        if (result.done) {
-          return emitter.end
-        }
-
-        return fx.run(
-          Emitter(
-            (b) => {
-              const a = result.value
-              const c = f(a, b)
-
-              result = iterator.next()
-
-              return pipe(
-                emitter.emit(c),
-                Effect.flatMap((x) => (result.done ? exitEarly : Effect.succeed(x))),
-              )
-            },
-            emitter.failCause,
-            emitter.end,
-          ),
-        )
-      }),
-      onEarlyExitFailure(emitter.end),
-    ),
-  )
-}

package/tools/benchmark.ts

@@ -1,159 +0,0 @@
-import tablemark from 'tablemark'
-
-export interface PerformanceTestCase<A> {
-  readonly name: string
-  readonly init: () => A
-  readonly run: (a: A) => unknown | Promise<unknown>
-}
-
-export function PerformanceTestCase<A>(
-  name: string,
-  init: () => A,
-  run: (a: A) => Promise<unknown>,
-): PerformanceTestCase<A> {
-  return { name, init, run }
-}
-
-export interface TestStats {
-  readonly average: number
-  readonly min: number
-  readonly max: number
-  readonly timeToInit: number
-  readonly overhead: number
-}
-
-export function TestStats(
-  average: number,
-  min: number,
-  max: number,
-  timeToInit: number,
-  overhead: number,
-): TestStats {
-  return { average, min, max, timeToInit, overhead }
-}
-
-export interface TestSuite {
-  readonly name: string
-  readonly tests: ReadonlyArray<PerformanceTestCase<any>>
-}
-
-export function TestSuite(name: string, tests: ReadonlyArray<PerformanceTestCase<any>>): TestSuite {
-  return { name, tests }
-}
-
-export interface TestSuiteResult {
-  readonly name: string
-  readonly stats: Readonly<Record<string, TestStats>>
-}
-
-export function TestSuiteResult(
-  name: string,
-  stats: Readonly<Record<string, TestStats>>,
-): TestSuiteResult {
-  return { name, stats }
-}
-
-export interface RunTestConfig {
-  readonly iterations: number
-  readonly getTime: () => number
-}
-
-export function RunTestConfig(iterations: number, getTime: () => number): RunTestConfig {
-  return { iterations, getTime }
-}
-
-export function runTestCaseWith(config: RunTestConfig) {
-  return async <A>(test: PerformanceTestCase<A>): Promise<Readonly<Record<string, TestStats>>> => {
-    const { iterations, getTime } = config
-    const initStartTime = getTime()
-    const init = test.init()
-    const initEndTime = getTime()
-
-    let total = 0
-    let min = Infinity
-    let max = 0
-
-    console.log(`Running ${test.name}...`)
-
-    for (let i = 0; i < iterations; i++) {
-      console.log(`Running ${test.name} (${i + 1} of ${iterations})`)
-      const startTime = getTime()
-      await test.run(init)
-      const endTime = getTime()
-      const elapsed = endTime - startTime
-
-      total += elapsed
-
-      if (elapsed < min) {
-        min = elapsed
-      } else if (elapsed > max) {
-        max = elapsed
-      }
-    }
-
-    return {
-      [test.name]: TestStats(
-        roundNumber(total / iterations),
-        roundNumber(min),
-        roundNumber(max),
-        roundNumber(initEndTime - initStartTime),
-        -1,
-      ),
-    }
-  }
-}
-
-export async function runTestSuite(
-  suite: TestSuite,
-  config: RunTestConfig,
-): Promise<TestSuiteResult> {
-  let results: Record<string, TestStats> = {}
-  const runTestCase = runTestCaseWith(config)
-
-  console.log(`\n\nRunning ${suite.name}...`)
-  await new Promise((resolve) => setTimeout(resolve, 1000))
-
-  for (const test of suite.tests) {
-    results = { ...results, ...(await runTestCase(test)) }
-  }
-
-  return TestSuiteResult(suite.name, addPercentile(results))
-}
-
-function roundNumber(n: number): number {
-  return parseFloat(n.toFixed(4))
-}
-
-function addPercentile(
-  stats: Readonly<Record<string, TestStats>>,
-): Readonly<Record<string, TestStats>> {
-  const newStats: Record<string, TestStats> = {}
-
-  const fastestToSlowest = Object.entries(stats).sort(([, a], [, b]) => a.average - b.average)
-  const fastestTime = fastestToSlowest[0][1].average
-
-  for (let i = 0; i < fastestToSlowest.length; ++i) {
-    const [name, stat] = fastestToSlowest[i]
-    newStats[name] = TestStats(
-      stat.average,
-      stat.min,
-      stat.max,
-      stat.timeToInit,
-      roundNumber(stat.average / fastestTime),
-    )
-  }
-
-  return newStats
-}
-
-export function printTestSuiteResult(result: TestSuiteResult): string {
-  return `## ${result.name}
-
-${tablemark(
-  Object.entries(result.stats).map(([library, stats]) => ({
-    library,
-    ...stats,
-  })),
-)}
-`
-}

package/tools/common.ts

@@ -1,43 +0,0 @@
-import { readFileSync, readdirSync } from 'node:fs'
-import { dirname, isAbsolute, join } from 'node:path'
-
-import fastGlob from 'fast-glob'
-
-export const ROOT_DIR = dirname(dirname(new URL(import.meta.url).pathname))
-export const SOURCE_DIR = join(ROOT_DIR, 'src')
-
-export const ROOT_FILES = ['exports']
-
-export function compiledFiles(name: string): readonly string[] {
-  const fileName = parseName(name)
-
-  return [`/${fileName}.d.ts`, `/${fileName}.d.ts.map`, `/${fileName}.js`, `/${fileName}.js.map`]
-}
-
-export function parseName(name: string): string {
-  return name.replace(/\.tsx?/, '')
-}
-
-export const MODULES: ReadonlyArray<string> = readdirSync(SOURCE_DIR)
-  .sort()
-  .filter(
-    (x) => x !== 'internal.ts' && x !== 'index.ts' && !x.endsWith('.test.ts') && !x.startsWith('.'),
-  )
-
-export function getRelativeFile(directory: string, fileName: string) {
-  return join(directory, fileName)
-}
-
-export function readRelativeFile(directory: string, fileName: string) {
-  return readFileSync(getRelativeFile(directory, fileName)).toString()
-}
-
-export function findFilePaths(directory: string, fileGlobs: readonly string[]): string[] {
-  return fastGlob
-    .sync(Array.from(fileGlobs), { cwd: directory, onlyFiles: true })
-    .map((x) => makeAbsolute(directory, x.toString()))
-}
-
-export function makeAbsolute(basePath: string, absoluteOrRelative: string): string {
-  return isAbsolute(absoluteOrRelative) ? absoluteOrRelative : join(basePath, absoluteOrRelative)
-}

package/tools/generatePackageExports.ts

@@ -1,100 +0,0 @@
-import fs from 'node:fs'
-import path, { extname } from 'node:path'
-import process from 'node:process'
-
-import { MODULES, ROOT_DIR, SOURCE_DIR, findFilePaths } from './common.js'
-
-const TSX_REGEX = /.tsx?$/
-const INDEX_REGEX = /\/?index$/
-
-if (new URL(import.meta.url).pathname === path.resolve(process.argv[1])) {
-  const packageJsonPath = path.join(ROOT_DIR, 'package.json')
-  const packageJsonContents = fs.readFileSync(packageJsonPath).toString()
-  const packageJson = JSON.parse(packageJsonContents)
-
-  packageJson.exports = createExports()
-
-  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2).trim() + `\n`)
-}
-
-type ExportMap = {
-  require: { default: string; types: string }
-  import: { default: string; types: string }
-}
-
-export function createExports() {
-  const exports: Record<string, ExportMap> = {
-    '.': {
-      require: {
-        default: './cjs/index.js',
-        types: './cjs/index.d.ts',
-      },
-      import: {
-        default: './esm/index.js',
-        types: './esm/index.d.ts',
-      },
-    },
-  }
-
-  for (const module of MODULES) {
-    const sourceDir = path.join(SOURCE_DIR, module)
-    const isDirectory = fs.statSync(sourceDir).isDirectory()
-    const name = module.replace(TSX_REGEX, '')
-
-    exports[`./${name}`] = {
-      require: {
-        default:
-          './' +
-          (isDirectory ? path.join('cjs', name, 'index.js') : path.join('cjs', `${name}.js`)),
-        types:
-          './' +
-          (isDirectory ? path.join('cjs', name, 'index.js') : path.join('cjs', `${name}.d.ts`)),
-      },
-      import: {
-        default:
-          './' +
-          (isDirectory ? path.join('esm', name, 'index.js') : path.join('esm', `${name}.js`)),
-        types:
-          './' +
-          (isDirectory ? path.join('esm', name, 'index.js') : path.join('esm', `${name}.d.ts`)),
-      },
-    }
-
-    if (!isDirectory) {
-      continue
-    }
-
-    const filePaths = findFilePaths(sourceDir, [
-      '!**/*.browser-test.ts',
-      '!**/*.test.ts',
-      '**/*.ts',
-    ])
-
-    for (const filePath of filePaths) {
-      const relativePath = path.relative(sourceDir, filePath)
-
-      if (extname(relativePath) !== '.ts') {
-        continue
-      }
-
-      const jsPath = relativePath.replace('.ts', '.js')
-      const dtsPath = relativePath.replace('.ts', '.d.ts')
-      const map: ExportMap = {
-        require: {
-          default: './' + path.join('cjs', name, jsPath),
-          types: './' + path.join('cjs', name, dtsPath),
-        },
-        import: {
-          default: './' + path.join('esm', name, jsPath),
-          types: './' + path.join('esm', name, dtsPath),
-        },
-      }
-
-      const relativeName = relativePath.replace(TSX_REGEX, '').replace(INDEX_REGEX, '')
-
-      exports[`./${name}${relativeName ? `/${relativeName}` : ''}`] = map
-    }
-  }
-
-  return exports
-}

package/tsconfig.base.json

@@ -1,33 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    },
-    "declaration": true,
-    "declarationMap": true,
-    "downlevelIteration": true,
-    "esModuleInterop": true,
-    "importHelpers": true,
-    "module": "esnext",
-    "moduleResolution": "NodeNext",
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "strictFunctionTypes": true,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true,
-    "sourceMap": true,
-    "target": "ES2022",
-    "lib": [
-      "DOM",
-      "ES2022"
-    ]
-  }
-}

package/tsconfig.build.cjs.json

@@ -1,32 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    },
-    "module": "commonjs",
-    "outDir": "cjs",
-    "plugins": [
-      // Transform paths in output .js files
-      {
-        "transform": "typescript-transform-paths"
-      },
-      // Transform paths in output .d.ts files (Include this line if you output declarations files)
-      {
-        "transform": "typescript-transform-paths",
-        "afterDeclarations": true
-      }
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "src/**/*.test.ts",
-    "tools"
-  ]
-}

package/tsconfig.build.esm.json

@@ -1,36 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    },
-    "module": "ES2015",
-    "outDir": "esm",
-    "plugins": [
-      // Transform paths in output .js files
-      {
-        "transform": "typescript-transform-paths"
-      },
-      // Transform paths in output .d.ts files (Include this line if you output declarations files)
-      {
-        "transform": "typescript-transform-paths",
-        "afterDeclarations": true
-      },
-      {
-        "transform": "@zoltu/typescript-transformer-append-js-extension/output/index.js",
-        "after": true
-      }
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "src/**/*.test.ts",
-    "tools"
-  ]
-}

package/tsconfig.test.json

@@ -1,17 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.base.json",
-  "compilerOptions": {
-    "allowJs": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    },
-    "outDir": "test"
-  },
-  "include": [
-    "src/**/*.test.ts"
-  ]
-}