@typed/fx 0.0.1

package/src/Trace/Trace.ts

@@ -0,0 +1,210 @@
+import { pipe } from 'hkt-ts'
+import * as A from 'hkt-ts/Array'
+import * as ASSOC from 'hkt-ts/Typeclass/Associative'
+import * as D from 'hkt-ts/Typeclass/Debug'
+import * as E from 'hkt-ts/Typeclass/Eq'
+import * as I from 'hkt-ts/Typeclass/Identity'
+import * as O from 'hkt-ts/Typeclass/Ord'
+import * as N from 'hkt-ts/number'
+import * as S from 'hkt-ts/string'
+
+import type { Cause } from '@/Cause/index.js'
+import { Stack } from '@/Stack/index.js'
+import * as StackFrame from '@/StackFrame/index.js'
+
+export type Trace = EmptyTrace | StackFrameTrace
+
+const INSTRUMENTED_REGEX = /^.+\s.+:[0-9]+:[0-9]+$/i
+
+export const isInstrumentedTrace = (trace: string) => INSTRUMENTED_REGEX.test(trace)
+
+export namespace Trace {
+  export const runtime = <E extends { stack?: string } = Error>(
+    error: E,
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    targetObject?: Function,
+  ) => new StackFrameTrace(StackFrame.getStackFrames(error, targetObject))
+
+  export const custom = (trace: string): StackFrameTrace => {
+    if (!isInstrumentedTrace(trace)) {
+      return new StackFrameTrace([
+        {
+          tag: 'Custom',
+          trace,
+        },
+      ])
+    }
+
+    const [methodFile, line, column] = trace.split(/:/g)
+    const [method, file] = methodFile.split(/\s/)
+    const stackFrame: StackFrame.StackFrame = {
+      tag: 'Instrumented',
+      file,
+      method,
+      line: parseFloat(line),
+      column: parseFloat(column),
+    }
+
+    return new StackFrameTrace([stackFrame])
+  }
+}
+
+export const EmptyTrace = {
+  tag: 'EmptyTrace',
+} as const
+
+export type EmptyTrace = typeof EmptyTrace
+
+export class StackFrameTrace {
+  readonly tag = 'StackFrameTrace'
+
+  constructor(readonly frames: StackFrame.StackFrames) {}
+}
+
+export const Eq: E.Eq<Trace> = E.sum<Trace>()('tag')({
+  EmptyTrace: E.AlwaysEqual,
+  StackFrameTrace: E.struct<StackFrameTrace>({
+    tag: E.AlwaysEqual,
+    frames: A.makeEq(StackFrame.Eq),
+  }),
+})
+
+export const Ord: O.Ord<Trace> = O.sum<Trace>()('tag')(
+  pipe(
+    N.Ord,
+    O.contramap((a) => (a === 'EmptyTrace' ? 0 : 1)),
+  ),
+)({
+  EmptyTrace: O.Static,
+  StackFrameTrace: O.struct<StackFrameTrace>({
+    tag: O.Static,
+    frames: A.makeOrd(StackFrame.Ord),
+  })(S.Ord),
+})
+
+export const Associative: ASSOC.Associative<Trace> = {
+  concat: (f, s) => {
+    if (f.tag === EmptyTrace.tag) {
+      return s
+    }
+
+    if (s.tag === EmptyTrace.tag) {
+      return f
+    }
+
+    return new StackFrameTrace([...f.frames, ...s.frames])
+  },
+}
+
+export const concat = Associative.concat
+
+export const Identity: I.Identity<Trace> = {
+  ...Associative,
+  id: EmptyTrace,
+}
+
+export const Debug: D.Debug<Trace> = D.sum<Trace>()('tag')({
+  EmptyTrace: {
+    debug: () => `<empty trace>`,
+  },
+  StackFrameTrace: {
+    debug: ({ frames }) => frames.map(StackFrame.debug).join('\n'),
+  },
+})
+
+export const debug = Debug.debug
+
+export function trimOverlappingTraces(current: Trace, incoming: Trace): Trace {
+  if (current.tag === EmptyTrace.tag) {
+    return incoming
+  }
+
+  if (incoming.tag === EmptyTrace.tag) {
+    return current
+  }
+
+  const frames = trimOverlappingFrames(
+    current.frames.slice(0, incoming.frames.length), // Only compare the same amount of values
+    incoming.frames,
+  )
+
+  return frames.length === 0
+    ? EmptyTrace
+    : new StackFrameTrace(trimOverlappingFrames(current.frames, incoming.frames))
+}
+
+function trimOverlappingFrames(
+  current: ReadonlyArray<StackFrame.StackFrame>,
+  incoming: ReadonlyArray<StackFrame.StackFrame>,
+): ReadonlyArray<StackFrame.StackFrame> {
+  // Clone our Array for mutation
+  const outgoing: Array<StackFrame.StackFrame> = [...incoming]
+
+  let cIndex = current.length - 1
+  let iIndex = 0
+  let deleted = 0
+
+  for (; cIndex > -1 && iIndex < incoming.length; ) {
+    const c = current[cIndex]
+    const i = incoming[iIndex]
+
+    // If neither are Runtime instructions, lets just break early
+    if (!(c.tag === 'Runtime' || i.tag === 'Runtime')) {
+      break
+    }
+
+    // Skip over custom/instrumented traces
+    if (c.tag !== 'Runtime') {
+      cIndex--
+
+      continue
+    }
+    if (i.tag !== 'Runtime') {
+      iIndex++
+
+      continue
+    }
+
+    // If we don't have a match, just break
+    if (!StackFrame.Eq.equals(c, i)) {
+      break
+    }
+
+    // Remove this Trace
+    outgoing.splice(iIndex - deleted++, 1)
+    cIndex--
+    iIndex++
+  }
+
+  return outgoing
+}
+
+export interface StackTrace extends Stack<Trace> {}
+
+// Traverse up the Stack<Trace> for a set amount of StackFrames.
+export function getTraceUpTo(trace: StackTrace, amount: number): Trace {
+  const frames: Array<StackFrame.StackFrame> = []
+
+  let current: StackTrace | null = trace
+
+  while (current && frames.length < amount) {
+    if (current.value.tag === 'StackFrameTrace') {
+      frames.push(...current.value.frames)
+    }
+
+    current = current.previous
+  }
+
+  return frames.length > 0 ? new StackFrameTrace(frames) : EmptyTrace
+}
+
+export function getTrimmedTrace<E>(cause: Cause<E>, stackTrace: StackTrace) {
+  const error =
+    (cause.tag === 'Unexpected' || cause.tag === 'Expected') && cause.error instanceof Error
+      ? cause.error
+      : new Error()
+  const trace = Trace.runtime(error, getTrimmedTrace)
+  const toCompare = getTraceUpTo(stackTrace, trace.frames.length)
+
+  return trimOverlappingTraces(toCompare, trace)
+}

package/src/Trace/index.ts

@@ -0,0 +1 @@
+export * from './Trace.js'

package/src/Tracing/plugin.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable import/no-named-as-default-member */
+import { relative } from 'path'
+
+import { ProgramPattern } from 'ts-patch'
+import ts from 'typescript'
+
+const INSTRUMENTED_REGEX = /^[a-z]+\s.+:[0-9]+:[0-9]+$/i
+
+const isInstrumentedTrace = (trace: string) => INSTRUMENTED_REGEX.test(trace)
+
+export interface TracingPluginOptions {
+  readonly root?: string
+  readonly rewritePaths?: ReadonlyArray<readonly [string, string]>
+}
+
+export const makeTracingTransformer = (program: ts.Program, config: TracingPluginOptions) => {
+  const checker = program.getTypeChecker()
+  const root = config?.root ?? program.getCompilerOptions().rootDir ?? process.cwd()
+
+  return (ctx: ts.TransformationContext) => {
+    return (sourceFile: ts.SourceFile): ts.SourceFile => {
+      const fileName = rewritePaths(relative(root, sourceFile.fileName), config.rewritePaths)
+
+      function getTrace(node: ts.Node, existingText?: string): ts.Expression {
+        const nodeEnd = sourceFile.getLineAndCharacterOfPosition(node.getEnd())
+
+        // Must be an expression, so we create a binary expression to concatenate the 2 parts of the string
+        // and to handle existing expressions in existingText.
+        const expression = ts.factory.createBinaryExpression(
+          ts.factory.createStringLiteral(
+            existingText ? trimQuotations(existingText) : node.getText(),
+          ),
+          ts.factory.createToken(ts.SyntaxKind.PlusToken),
+          ts.factory.createStringLiteral(
+            ` ${fileName}:${nodeEnd.line + 1}:${nodeEnd.character + 1}`,
+          ),
+        )
+
+        return expression
+      }
+
+      function visitor(node: ts.Node): ts.VisitResult<ts.Node> {
+        if (ts.isCallExpression(node)) {
+          // Continue processing any arguments that might be CallExpressions
+          const processedArguments = ts.visitNodes(node.arguments, visitor)
+
+          // Resolve signature to get the declaration parameters.
+          const signature =
+            checker.getResolvedSignature(node) ?? getSignatureIfSole(checker, node.expression)
+          const signatureDeclaration = signature?.getDeclaration()
+          const declarationParameters = Array.from(signatureDeclaration?.parameters || [])
+
+          // Grab the last argument and last declaration parameter.
+          const lastParameter = processedArguments[processedArguments.length - 1]
+          const lastDeclarationParameter = declarationParameters[declarationParameters.length - 1]
+
+          // Check if this function should append a trace, and how.
+          const isTraceLastParameter = lastDeclarationParameter?.name.getText() === '__trace'
+          const haveNotProvidedTrace =
+            processedArguments.length === declarationParameters.length - 1
+          const traceIsMissingLocation =
+            processedArguments.length === declarationParameters.length && lastParameter
+              ? lastParameter.getText(sourceFile) !== '__trace' &&
+                !isInstrumentedTrace(lastParameter.getText(sourceFile))
+              : false
+          const shouldAppendTrace =
+            isTraceLastParameter && (haveNotProvidedTrace || traceIsMissingLocation)
+
+          // Update the CallExpression
+          return ts.factory.updateCallExpression(
+            node,
+            ts.visitNode(node.expression, visitor), // Process the expression
+            node.typeArguments,
+            shouldAppendTrace
+              ? haveNotProvidedTrace
+                ? [...node.arguments, getTrace(node.expression)] // Append new Trace
+                : [
+                    // Ammend existing custom Trace with line numbers
+                    ...node.arguments.slice(0, -1),
+                    getTrace(node.expression, lastParameter.getText(sourceFile)),
+                  ]
+              : node.arguments, // Don't do anything
+          )
+        }
+
+        // Ensure we traverse through variable declarations
+        if (ts.isVariableDeclaration(node)) {
+          return ts.factory.updateVariableDeclaration(
+            node,
+            node.name,
+            node.exclamationToken,
+            node.type,
+            ts.visitEachChild(node.initializer, visitor, ctx),
+          )
+        }
+
+        // Keep traversing through the rest of the tree
+        return ts.visitEachChild(node, visitor, ctx)
+      }
+
+      return ts.visitEachChild(sourceFile, visitor, ctx)
+    }
+  }
+}
+
+export default makeTracingTransformer as ProgramPattern
+
+function getSignatureIfSole(
+  checker: ts.TypeChecker,
+  node: ts.Expression,
+): ts.Signature | undefined {
+  const ds = checker.getTypeAtLocation(node).getCallSignatures()
+
+  if (ds?.length !== 1) {
+    return undefined
+  }
+
+  return ds?.[0]
+}
+
+const quotes = [`'`, `"`]
+
+function trimQuotations(s: string) {
+  if (s.length === 0) {
+    return s
+  }
+
+  if (quotes.includes(s[0])) {
+    s = s.slice(1)
+  }
+
+  if (quotes.includes(s[s.length - 1])) {
+    s = s.slice(0, -1)
+  }
+
+  return s
+}
+
+function rewritePaths(
+  path: string,
+  rewritePaths?: ReadonlyArray<readonly [string, string]>,
+): string {
+  if (!rewritePaths) {
+    return path
+  }
+
+  for (const [from, to] of rewritePaths) {
+    const fromRegex = new RegExp(from, 'g')
+
+    path = path.replace(fromRegex, to)
+  }
+
+  return path
+}

package/src/Tracing/vite.ts

@@ -0,0 +1,72 @@
+import { Project } from 'ts-morph'
+import ts from 'typescript'
+import type { Plugin } from 'vite'
+
+import { makeTracingTransformer } from './plugin.js'
+
+export interface TracingParams {
+  // Where to find the tsconfig.json file.
+  readonly tsconfig: string
+
+  // Where to run this plugin
+  readonly build?: boolean
+  readonly serve?: boolean
+  readonly dev?: boolean
+  readonly ssr?: boolean
+}
+
+const jsRegex = /.([c|m]?jsx?)$/
+const jsMapRegex = /.js.map$/
+const name = '@typed/fx/Tracing'
+
+export function tracingPlugin(params: TracingParams): Plugin {
+  console.info(`${name} :: Setting up TypeScript project...`)
+  const project = new Project({ tsConfigFilePath: params.tsconfig })
+  console.info(`${name} :: TypeScript project ready.`)
+
+  let customTransformers: ts.CustomTransformers | undefined
+  return {
+    name,
+    apply(_, env) {
+      const shouldRunCommand = env.command === 'build' ? params.build ?? true : params.serve ?? true
+      const shouldRunMode = env.mode === 'dev' ? params.dev ?? true : true
+      const shouldRunSsr = env.ssrBuild === true ? params.ssr ?? true : true
+
+      return shouldRunCommand && shouldRunMode && shouldRunSsr
+    },
+
+    configResolved(config) {
+      customTransformers = {
+        before: [
+          makeTracingTransformer(project.getProgram().compilerObject, {
+            root: config.root,
+          }),
+        ],
+      }
+    },
+
+    async transform(src, id) {
+      if (id.includes('node_modules')) {
+        return
+      }
+
+      const sourceFile = project.createSourceFile(id, src, { overwrite: true })
+      const output = project.emitToMemory({
+        targetSourceFile: sourceFile,
+        customTransformers,
+      })
+      const files = output.getFiles()
+      const source = files.find((x) => jsRegex.test(x.filePath))
+      const sourceMap = files.find((x) => jsMapRegex.test(x.filePath))
+
+      if (!source) {
+        return
+      }
+
+      return {
+        code: source.text,
+        map: sourceMap?.text,
+      }
+    },
+  }
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export * as Atomic from './Atomic/index.js'
+export * as Cause from './Cause/index.js'
+export * as Clock from './Clock/index.js'
+export * as Disposable from './Disposable/index.js'
+export * as Duration from './Duration/index.js'
+export * as Env from './Env/index.js'
+export * as Exit from './Exit/index.js'
+export * as Fiber from './Fiber/index.js'
+export * as FiberContext from './FiberContext/index.js'
+export * as FiberId from './FiberId/index.js'
+export * as FiberRef from './FiberRef/index.js'
+export * as FiberRefs from './FiberRefs/index.js'
+export * as FiberRuntime from './FiberRuntime/index.js'
+export * as FiberStatus from './FiberStatus/index.js'
+export * as Finalizer from './Finalizer/index.js'
+export * as Future from './Future/index.js'
+export * as Fx from './Fx/index.js'
+export * from './Fx/index.js'
+export * as Layer from './Layer/index.js'
+export * as Logger from './Logger/index.js'
+export * as Platform from './Platform/index.js'
+export * as Ref from './Ref/index.js'
+export * as Schedule from './Schedule/index.js'
+export * as Scope from './Scope/index.js'
+export * as Semaphore from './Semaphore/index.js'
+export * as Service from './Service/index.js'
+export * as Stack from './Stack/index.js'
+export * as StackFrame from './StackFrame/index.js'
+export * as Supervisor from './Supervisor/index.js'
+export * as Tagged from './Tagged/index.js'
+export * as Time from './Time/index.js'
+export * as Timeline from './Timeline/index.js'
+export * as Timer from './Timer/index.js'
+export * as Trace from './Trace/index.js'

package/src/internal.ts

@@ -0,0 +1,33 @@
+import { ListOf } from 'ts-toolbelt/out/Union/ListOf.js'
+
+/**
+ * Redistribute every union and strictly exclude values.
+ */
+export type StrictExclude<T, U> = ListOf<T> extends readonly [infer Head, ...infer Tail]
+  ? Head extends U
+    ? StrictExclude<Tail[number], U>
+    : Head | StrictExclude<Tail[number], U>
+  : never
+
+/**
+ * Redistribute every union and strictly extract values.
+ */
+export type StrictExtract<T, U> = ListOf<T> extends readonly [infer Head, ...infer Tail]
+  ? Head extends U
+    ? Head | StrictExtract<Tail[number], U>
+    : StrictExtract<Tail[number], U>
+  : never
+
+export type StrictExcludeAll<T, U extends readonly any[]> = U extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? StrictExcludeAll<StrictExclude<T, Head>, Tail>
+  : T
+
+export type StrictExtractAll<T, U extends readonly any[]> = U extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? StrictExtractAll<StrictExtract<T, Head>, Tail>
+  : T

package/tools/common.ts

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,32 @@
+{
+  "$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,
+    "strict": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "sourceMap": true,
+    "target": "ES2022",
+    "lib": [
+      "DOM",
+      "ES2022"
+    ]
+  }
+}