1. Top
  2. macana
  3. Files
  4. page_builder
  5. default_theme
  6. builder.tsx
macana

Static site generator for Obsidian Vault

  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
  104. 104
  105. 105
  106. 106
  107. 107
  108. 108
  109. 109
  110. 110
  111. 111
  112. 112
  113. 113
  114. 114
  115. 115
  116. 116
  117. 117
  118. 118
  119. 119 
// SPDX-FileCopyrightText: 2024 Shota FUJI <pockawoooh@gmail.com>
//
// SPDX-License-Identifier: Apache-2.0

/** @jsx h */

import { h, renderSSR } from "../../deps/deno.land/x/nano_jsx/mod.ts";
import { fromMarkdown } from "../../deps/esm.sh/mdast-util-from-markdown/mod.ts";

import type {
	Document,
	DocumentDirectory,
	DocumentTree,
} from "../../tree_builder/interface.ts";
import type { BuildParameters, PageBuilder } from "../interface.ts";

import * as css from "./css.ts";

import * as Html from "./components/html.tsx";

import { PathResolverProvider } from "./contexts/path_resolver.tsx";

interface InnerBuildParameters {
	items: ReadonlyArray<DocumentDirectory | Document>;

	tree: DocumentTree;

	locale: string;

	pathPrefix?: readonly string[];

	buildParameters: Omit<BuildParameters, "documentTree">;
}

export class DefaultThemeBuilder implements PageBuilder {
	#copyright: string;

	constructor(copyright: string) {
		this.#copyright = copyright;
	}

	async build(
		{ documentTree, fileSystemReader, fileSystemWriter }: BuildParameters,
	) {
		const styles = css.serialize(
			Html.styles,
		);

		await fileSystemWriter.write(
			["assets", "global.css"],
			new TextEncoder().encode(styles),
		);

		for (const [locale, items] of documentTree.locales) {
			await this.#buildLocale({
				items,
				tree: documentTree,
				locale,
				pathPrefix: locale === documentTree.defaultLocale ? [] : [locale],
				buildParameters: { fileSystemWriter, fileSystemReader },
			});
		}
	}

	async #buildLocale(
		{ items, tree, locale, pathPrefix = [], buildParameters }:
			InnerBuildParameters,
	): Promise<void> {
		const { fileSystemWriter } = buildParameters;

		for (const item of items) {
			if ("file" in item) {
				const content = await item.file.read();

				if (item.file.name.endsWith(".md")) {
					const html = "<!DOCTYPE html>" + renderSSR(
						() => (
							// Adds 1 to depth due to	`<name>/index.html` conversion.
							<PathResolverProvider depth={pathPrefix.length + 1}>
								<Html.View
									tree={tree}
									content={fromMarkdown(content)}
									document={item}
									locale={locale}
									copyright={this.#copyright}
								/>
							</PathResolverProvider>
						),
					);

					const enc = new TextEncoder();

					await fileSystemWriter.write([
						...pathPrefix,
						item.file.name.replace(/\.md$/, ""),
						"index.html",
					], enc.encode(html));
				}

				if (item.file.name.endsWith(".canvas")) {
					// TODO: Proper logging
					console.warn(
						"Default theme page builder does not support Canvas yet.",
					);
				}

				continue;
			}

			await this.#buildLocale({
				items: item.entries,
				tree,
				locale,
				pathPrefix: [...pathPrefix, item.directory.name],
				buildParameters,
			});
		}
	}
}