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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
// TODO(petamoriken): enable prefer-primordials for node polyfills
// deno-lint-ignore-file prefer-primordials
import {
BinaryOptionsArgument,
FileOptionsArgument,
getEncoding,
TextOptionsArgument,
} from "ext:deno_node/_fs/_fs_common.ts";
import { Buffer } from "node:buffer";
import { readAll } from "ext:deno_io/12_io.js";
import { FileHandle } from "ext:deno_node/internal/fs/handle.ts";
import { pathFromURL } from "ext:deno_web/00_infra.js";
import {
BinaryEncodings,
Encodings,
TextEncodings,
} from "ext:deno_node/_utils.ts";
import { FsFile } from "ext:deno_fs/30_fs.js";
function maybeDecode(data: Uint8Array, encoding: TextEncodings): string;
function maybeDecode(
data: Uint8Array,
encoding: BinaryEncodings | null,
): Buffer;
function maybeDecode(
data: Uint8Array,
encoding: Encodings | null,
): string | Buffer {
const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
if (encoding && encoding !== "binary") return buffer.toString(encoding);
return buffer;
}
type TextCallback = (err: Error | null, data?: string) => void;
type BinaryCallback = (err: Error | null, data?: Buffer) => void;
type GenericCallback = (err: Error | null, data?: string | Buffer) => void;
type Callback = TextCallback | BinaryCallback | GenericCallback;
type Path = string | URL | FileHandle;
export function readFile(
path: Path,
options: TextOptionsArgument,
callback: TextCallback,
): void;
export function readFile(
path: Path,
options: BinaryOptionsArgument,
callback: BinaryCallback,
): void;
export function readFile(
path: Path,
options: null | undefined | FileOptionsArgument,
callback: BinaryCallback,
): void;
export function readFile(path: string | URL, callback: BinaryCallback): void;
export function readFile(
path: Path,
optOrCallback?: FileOptionsArgument | Callback | null | undefined,
callback?: Callback,
) {
path = path instanceof URL ? pathFromURL(path) : path;
let cb: Callback | undefined;
if (typeof optOrCallback === "function") {
cb = optOrCallback;
} else {
cb = callback;
}
const encoding = getEncoding(optOrCallback);
let p: Promise<Uint8Array>;
if (path instanceof FileHandle) {
const fsFile = new FsFile(path.fd, Symbol.for("Deno.internal.FsFile"));
p = readAll(fsFile);
} else {
p = Deno.readFile(path);
}
if (cb) {
p.then((data: Uint8Array) => {
if (encoding && encoding !== "binary") {
const text = maybeDecode(data, encoding);
return (cb as TextCallback)(null, text);
}
const buffer = maybeDecode(data, encoding);
(cb as BinaryCallback)(null, buffer);
}, (err) => cb && cb(err));
}
}
export function readFilePromise(
path: Path,
options?: FileOptionsArgument | null | undefined,
// deno-lint-ignore no-explicit-any
): Promise<any> {
return new Promise((resolve, reject) => {
readFile(path, options, (err, data) => {
if (err) reject(err);
else resolve(data);
});
});
}
export function readFileSync(
path: string | URL,
opt: TextOptionsArgument,
): string;
export function readFileSync(
path: string | URL,
opt?: BinaryOptionsArgument,
): Buffer;
export function readFileSync(
path: string | URL,
opt?: FileOptionsArgument,
): string | Buffer {
path = path instanceof URL ? pathFromURL(path) : path;
const data = Deno.readFileSync(path);
const encoding = getEncoding(opt);
if (encoding && encoding !== "binary") {
const text = maybeDecode(data, encoding);
return text;
}
const buffer = maybeDecode(data, encoding);
return buffer;
}
|
