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
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103

// SPDX-FileCopyrightText: 2024 Shota FUJI <pockawoooh@gmail.com>
//
// SPDX-License-Identifier: Apache-2.0

import type {
	DirectoryReader,
	FileReader,
} from "../filesystem_reader/interface.ts";
import type { MetadataParser } from "../metadata_parser/interface.ts";
import type {
	BuildParameters,
	Document,
	DocumentDirectory,
	DocumentTree,
	TreeBuilder,
} from "./interface.ts";

export interface SingleLocaleTreeBuilderConfig {
	/**
	 * Locale string to use.
	 */
	locale: string;

	/**
	 * Callback function to be invoked on every file and directory.
	 * If this function returned true, the file or directory is skipped and does not
	 * appear on the resulted document tree.
	 */
	ignore?(fileOrDirectory: FileReader | DirectoryReader): boolean;
}

export class SingleLocaleTreeBuilder implements TreeBuilder {
	#locale: string;
	#ignore?: (fileOrDirectory: FileReader | DirectoryReader) => boolean;

	constructor({ locale, ignore }: SingleLocaleTreeBuilderConfig) {
		this.#locale = locale;
		this.#ignore = ignore;
	}

	async build(
		{ fileSystemReader, metadataParser }: BuildParameters,
	): Promise<DocumentTree> {
		const root = await fileSystemReader.getRootDirectory();

		const children = await root.read();

		const entries = await Promise.all(
			children.map((child) => this.#build(child, metadataParser)),
		);

		const map = new Map<string, Array<Document | DocumentDirectory>>();
		map.set(
			this.#locale,
			entries.filter((entry): entry is NonNullable<typeof entry> => !!entry),
		);

		return {
			locales: map,
			defaultLocale: this.#locale,
		};
	}

	async #build(
		node: FileReader | DirectoryReader,
		metadataParser: MetadataParser,
	): Promise<DocumentDirectory | Document | null> {
		if (this.#ignore && this.#ignore(node)) {
			// TODO: Debug log
			return null;
		}

		const metadata = await metadataParser.parse(node);

		// This SHOULD have check for `metadata.skip` being `true`. However, a bug
		// (or "feature") in TypeScript breaks type-narrowing by doing so.
		if ("skip" in metadata) {
			// TODO: Debug log
			return null;
		}

		if (node.type === "file") {
			return {
				metadata,
				file: node,
			};
		}

		const children = await node.read();

		const entries = await Promise.all(
			children.map((child) => this.#build(child, metadataParser)),
		);

		return {
			metadata,
			directory: node,
			entries: entries.filter((child): child is NonNullable<typeof child> =>
				!!child
			),
		};
	}
}