DRY more things up

Author: cte

packages/build/src/esbuild.ts

@@ -0,0 +1,205 @@
+import * as fs from "fs"
+import * as path from "path"
+
+import { ViewsContainer, Views, Menus, Configuration, contributesSchema } from "./types.js"
+
+export function copyPaths(copyPaths: [string, string][], srcDir: string, dstDir: string) {
+	copyPaths.forEach(([srcRelPath, dstRelPath]) => {
+		const stats = fs.lstatSync(path.join(srcDir, srcRelPath))
+
+		if (stats.isDirectory()) {
+			if (fs.existsSync(path.join(dstDir, dstRelPath))) {
+				fs.rmSync(path.join(dstDir, dstRelPath), { recursive: true })
+			}
+
+			fs.mkdirSync(path.join(dstDir, dstRelPath), { recursive: true })
+
+			const count = copyDir(path.join(srcDir, srcRelPath), path.join(dstDir, dstRelPath), 0)
+			console.log(`[copyPaths] Copied ${count} files from ${srcRelPath} to ${dstRelPath}`)
+		} else {
+			fs.copyFileSync(path.join(srcDir, srcRelPath), path.join(dstDir, dstRelPath))
+			console.log(`[copyPaths] Copied ${srcRelPath} to ${dstRelPath}`)
+		}
+	})
+}
+
+export function copyDir(srcDir: string, dstDir: string, count: number): number {
+	const entries = fs.readdirSync(srcDir, { withFileTypes: true })
+
+	for (const entry of entries) {
+		const srcPath = path.join(srcDir, entry.name)
+		const dstPath = path.join(dstDir, entry.name)
+
+		if (entry.isDirectory()) {
+			fs.mkdirSync(dstPath, { recursive: true })
+			count = copyDir(srcPath, dstPath, count)
+		} else {
+			count = count + 1
+			fs.copyFileSync(srcPath, dstPath)
+		}
+	}
+
+	return count
+}
+
+export function copyWasms(srcDir: string, distDir: string): void {
+	const nodeModulesDir = path.join(srcDir, "node_modules")
+
+	fs.mkdirSync(distDir, { recursive: true })
+
+	// Tiktoken WASM file.
+	fs.copyFileSync(
+		path.join(nodeModulesDir, "tiktoken", "lite", "tiktoken_bg.wasm"),
+		path.join(distDir, "tiktoken_bg.wasm"),
+	)
+
+	console.log(`[copyWasms] Copied tiktoken WASMs to ${distDir}`)
+
+	// Also copy Tiktoken WASMs to the workers directory.
+	const workersDir = path.join(distDir, "workers")
+	fs.mkdirSync(workersDir, { recursive: true })
+
+	fs.copyFileSync(
+		path.join(nodeModulesDir, "tiktoken", "lite", "tiktoken_bg.wasm"),
+		path.join(workersDir, "tiktoken_bg.wasm"),
+	)
+
+	console.log(`[copyWasms] Copied tiktoken WASMs to ${workersDir}`)
+
+	// Main tree-sitter WASM file.
+	fs.copyFileSync(
+		path.join(nodeModulesDir, "web-tree-sitter", "tree-sitter.wasm"),
+		path.join(distDir, "tree-sitter.wasm"),
+	)
+
+	console.log(`[copyWasms] Copied tree-sitter.wasm to ${distDir}`)
+
+	// Copy language-specific WASM files.
+	const languageWasmDir = path.join(nodeModulesDir, "tree-sitter-wasms", "out")
+
+	if (!fs.existsSync(languageWasmDir)) {
+		throw new Error(`Directory does not exist: ${languageWasmDir}`)
+	}
+
+	// Dynamically read all WASM files from the directory instead of using a hardcoded list.
+	const wasmFiles = fs.readdirSync(languageWasmDir).filter((file) => file.endsWith(".wasm"))
+
+	wasmFiles.forEach((filename) => {
+		fs.copyFileSync(path.join(languageWasmDir, filename), path.join(distDir, filename))
+	})
+
+	console.log(`[copyWasms] Copied ${wasmFiles.length} tree-sitter language wasms to ${distDir}`)
+}
+
+export function copyLocales(srcDir: string, distDir: string): void {
+	const destDir = path.join(distDir, "i18n", "locales")
+	fs.mkdirSync(destDir, { recursive: true })
+	const count = copyDir(path.join(srcDir, "i18n", "locales"), destDir, 0)
+	console.log(`[copyLocales] Copied ${count} locale files to ${destDir}`)
+}
+
+export function setupLocaleWatcher(srcDir: string, distDir: string) {
+	const localesDir = path.join(srcDir, "i18n", "locales")
+
+	if (!fs.existsSync(localesDir)) {
+		console.warn(`Cannot set up watcher: Source locales directory does not exist: ${localesDir}`)
+		return
+	}
+
+	console.log(`Setting up watcher for locale files in ${localesDir}`)
+
+	let debounceTimer: NodeJS.Timeout | null = null
+
+	const debouncedCopy = () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer)
+		}
+
+		// Wait 300ms after last change before copying.
+		debounceTimer = setTimeout(() => {
+			console.log("Locale files changed, copying...")
+			copyLocales(srcDir, distDir)
+		}, 300)
+	}
+
+	try {
+		fs.watch(localesDir, { recursive: true }, (_eventType, filename) => {
+			if (filename && filename.endsWith(".json")) {
+				console.log(`Locale file ${filename} changed, triggering copy...`)
+				debouncedCopy()
+			}
+		})
+		console.log("Watcher for locale files is set up")
+	} catch (error) {
+		console.error(
+			`Error setting up watcher for ${localesDir}:`,
+			error instanceof Error ? error.message : "Unknown error",
+		)
+	}
+}
+
+export function generatePackageJson({
+	packageJson: { contributes, ...packageJson },
+	overrideJson,
+	substitution,
+}: {
+	packageJson: Record<string, any>
+	overrideJson: Record<string, any>
+	substitution: [string, string]
+}) {
+	const { viewsContainers, views, commands, menus, submenus, configuration } = contributesSchema.parse(contributes)
+	const [from, to] = substitution
+
+	return {
+		...packageJson,
+		...overrideJson,
+		contributes: {
+			viewsContainers: transformArrayRecord<ViewsContainer>(viewsContainers, from, to, ["id"]),
+			views: transformArrayRecord<Views>(views, from, to, ["id"]),
+			commands: transformArray(commands, from, to, "command"),
+			menus: transformArrayRecord<Menus>(menus, from, to, ["command", "submenu", "when"]),
+			submenus: transformArray(submenus, from, to, "id"),
+			configuration: {
+				title: configuration.title,
+				properties: transformRecord<Configuration["properties"]>(configuration.properties, from, to),
+			},
+		},
+	}
+}
+
+function transformArrayRecord<T>(obj: Record<string, any[]>, from: string, to: string, props: string[]): T {
+	return Object.entries(obj).reduce(
+		(acc, [key, ary]) => ({
+			...acc,
+			[key.replace(from, to)]: ary.map((item) => {
+				const transformedItem = { ...item }
+
+				for (const prop of props) {
+					if (prop in item && typeof item[prop] === "string") {
+						transformedItem[prop] = item[prop].replace(from, to)
+					}
+				}
+
+				return transformedItem
+			}),
+		}),
+		{} as T,
+	)
+}
+
+function transformArray<T>(arr: any[], from: string, to: string, idProp: string): T[] {
+	return arr.map(({ [idProp]: id, ...rest }) => ({
+		[idProp]: id.replace(from, to),
+		...rest,
+	}))
+}
+
+function transformRecord<T>(obj: Record<string, any>, from: string, to: string): T {
+	return Object.entries(obj).reduce(
+		(acc, [key, value]) => ({
+			...acc,
+			[key.replace(from, to)]: value,
+		}),
+		{} as T,
+	)
+}

packages/build/src/git.ts

@@ -0,0 +1,11 @@
+import { execSync } from "child_process"
+
+export function getGitSha() {
+	let gitSha = undefined
+
+	try {
+		gitSha = execSync("git rev-parse HEAD").toString().trim()
+	} catch (e) {}
+
+	return gitSha
+}