FilesExpand file tree

 main

/

bufferedWriter.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

100 lines (93 loc) · 2.52 KB

 main

/

bufferedWriter.ts

Copy path

Top

File metadata and controls

• Code
• Blame

100 lines (93 loc) · 2.52 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

type WriteFn = (content: string) => void

export type BufferedWriter = {

write: (content: string) => void

flush: () => void

dispose: () => void

}

export function createBufferedWriter({

writeFn,

flushIntervalMs = 1000,

maxBufferSize = 100,

maxBufferBytes = Infinity,

immediateMode = false,

}: {

writeFn: WriteFn

flushIntervalMs?: number

maxBufferSize?: number

maxBufferBytes?: number

immediateMode?: boolean

}): BufferedWriter {

let buffer: string[] = []

let bufferBytes = 0

let flushTimer: NodeJS.Timeout | null = null

// Batch detached by overflow that hasn't been written yet. Tracked so

// flush()/dispose() can drain it synchronously if the process exits

// before the setImmediate fires.

let pendingOverflow: string[] | null = null

function clearTimer(): void {

if (flushTimer) {

clearTimeout(flushTimer)

flushTimer = null

}

}

function flush(): void {

if (pendingOverflow) {

writeFn(pendingOverflow.join(''))

pendingOverflow = null

}

if (buffer.length === 0) return

writeFn(buffer.join(''))

buffer = []

bufferBytes = 0

clearTimer()

}

function scheduleFlush(): void {

if (!flushTimer) {

flushTimer = setTimeout(flush, flushIntervalMs)

}

}

// Detach the buffer synchronously so the caller never waits on writeFn.

// writeFn may block (e.g. errorLogSink.ts appendFileSync) — if overflow fires

// mid-render or mid-keystroke, deferring the write keeps the current tick

// short. Timer-based flushes already run outside user code paths so they

// stay synchronous.

function flushDeferred(): void {

if (pendingOverflow) {

// A previous overflow write is still queued. Coalesce into it to

// preserve ordering — writes land in a single setImmediate-ordered batch.

pendingOverflow.push(...buffer)

buffer = []

bufferBytes = 0

clearTimer()

return

}

const detached = buffer

buffer = []

bufferBytes = 0

clearTimer()

pendingOverflow = detached

setImmediate(() => {

const toWrite = pendingOverflow

pendingOverflow = null

if (toWrite) writeFn(toWrite.join(''))

})

}

return {

write(content: string): void {

if (immediateMode) {

writeFn(content)

return

}

buffer.push(content)

bufferBytes += content.length

scheduleFlush()

if (buffer.length >= maxBufferSize || bufferBytes >= maxBufferBytes) {

flushDeferred()

}

},

flush,

dispose(): void {

flush()

},

}

}