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

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

interface Css {
	readonly chunks: ReadonlySet<string>;
}

/**
 * Just for syntax highlighting.
 */
export function css(
	tmpl: readonly string[],
	...params: readonly string[]
): Css {
	const code = cssTmplBuilder(tmpl, params);

	return {
		chunks: new Set([code]),
	};
}

function cssTmplBuilder(
	tmpl: readonly string[],
	params: readonly string[],
): string {
	if (!tmpl.length) {
		return "";
	}

	const [thead, ...trest] = tmpl;

	if (!params.length || trest.length === 0) {
		return thead;
	}

	const [phead, ...prest] = params;

	return thead + phead + cssTmplBuilder(trest, prest);
}

export function join(...units: readonly Css[]): Css {
	const result = new Set<string>();

	// `Set.prototype.union` method is not widely implemented yet.
	for (const unit of units) {
		for (const chunk of unit.chunks) {
			result.add(chunk);
		}
	}

	return {
		chunks: result,
	};
}

export function serialize(css: Css): string {
	return Array.from(css.chunks.values()).join("\n");
}

/**
 * This function returns an object whose every propery value is
 * class name string.
 *
 * The purpose of this function is to create namespaced (scoped)
 * class while keeping short character count for class name strings.
 *
 * As this function uses indices for class names, removing a name
 * from the list may cause broken style if a user loads stale CSS
 * and fresh HTML (or vice-versa). In order to avoid this, you can
 * replace the obsolete name with `null`, so this function skips
 * the index that later names keep its indices.
 *
 * @example
 * const c = buildClasses("foo", ["bar", null, "baz"]);
 * assertEquals(c.bar, "foo__0");
 * assertEquals(c.baz, "foo__2");
 */
export function buildClasses<Name extends string | null>(
	prefix: string,
	names: readonly Name[],
): Record<Exclude<Name, null>, string> {
	return Object.fromEntries(
		names.map((name, i) => name ? [name, `${prefix}__${i.toString(31)}`] : null)
			.filter((entry): entry is NonNullable<typeof entry> => !!entry),
	);
}