1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75

// This script reads given file and reports its filesize in raw bytes and gziped bytes.

import { argv, file, inspect, gzipSync } from "bun";
import * as commander from "commander";

import { bytesToString } from "./_filesize.js";

// --- MODULE

interface NetworkFilesize {
  raw: number;
  gzip: number;
}

export function getNetworkFilesize(
  input: ArrayBuffer | Uint8Array | string,
): NetworkFilesize {
  let buf: Uint8Array | Buffer;
  if (input instanceof Uint8Array) {
    buf = input;
  } else if (input instanceof ArrayBuffer) {
    buf = Buffer.from(input);
  } else if (typeof input === "string") {
    const enc = new TextEncoder();
    buf = enc.encode(input);
  } else {
    throw new Error(
      `First argument of the getNetworkFilesize() must be one of ArrayBuffer, Uint8Array, or string. Got "` +
        inspect(input) +
        `".`,
    );
  }

  return {
    raw: buf.byteLength,
    gzip: gzipSync(buf instanceof Uint8Array ? buf : Buffer.from(buf))
      .byteLength,
  };
}

export function printFilesize({ raw, gzip }: NetworkFilesize): void {
  console.log(
    "raw = %s, gzip = %s",
    bytesToString(raw, true),
    bytesToString(gzip, true),
  );
}

// --- CLI

interface Options {
  json?: boolean;
}

async function run(filepath: string, { json = false }: Options) {
  const target = file(filepath);

  const size = getNetworkFilesize(await target.arrayBuffer());

  if (json) {
    console.log(JSON.stringify(size));
    return;
  }

  printFilesize(size);
}

if (import.meta.main) {
  const program = commander.program
    .option("-J, --json")
    .argument("<path>", "File to analyze")
    .action(run);

  await program.parseAsync(argv);
}