jsrepo 1.0.0

package/src/config/index.ts

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import * as v from 'valibot';
+import { Err, Ok, type Result } from '../blocks/types/result';
+
+const CONFIG_NAME = 'blocks.json';
+
+const schema = v.object({
+	$schema: v.string(),
+	repos: v.optional(v.array(v.string()), []),
+	includeTests: v.boolean(),
+	path: v.pipe(v.string(), v.minLength(1)),
+	watermark: v.optional(v.boolean(), true),
+});
+
+const getConfig = (): Result<Config, string> => {
+	if (!fs.existsSync(CONFIG_NAME)) {
+		return Err('Could not find your configuration file! Please run `npx jsrepo init`.');
+	}
+
+	const config = v.safeParse(schema, JSON.parse(fs.readFileSync(CONFIG_NAME).toString()));
+
+	if (!config.success) {
+		return Err('There was an error reading your `blocks.json` file!');
+	}
+
+	return Ok(config.output);
+};
+
+type Config = v.InferOutput<typeof schema>;
+
+export { type Config, CONFIG_NAME, getConfig, schema };

package/src/index.ts

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { program } from 'commander';
+import * as commands from './commands';
+import type { CLIContext } from './utils/context';
+
+const resolveRelativeToRoot = (p: string): string => {
+	const dirname = fileURLToPath(import.meta.url);
+	return path.join(dirname, '../..', p);
+};
+
+// get version from package.json
+const { version, name, description, repository } = JSON.parse(
+	fs.readFileSync(resolveRelativeToRoot('package.json'), 'utf-8')
+);
+
+const context: CLIContext = {
+	package: {
+		name,
+		description,
+		version,
+		repository,
+	},
+	resolveRelativeToRoot,
+};
+
+program
+	.name(name)
+	.description(description)
+	.version(version)
+	.addCommand(commands.add)
+	.addCommand(commands.init)
+	.addCommand(commands.test)
+	.addCommand(commands.build)
+	.addCommand(commands.diff);
+
+program.parse();
+
+export { context };

package/src/utils/build.ts

@@ -0,0 +1,189 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import color from 'chalk';
+import { program } from 'commander';
+import * as v from 'valibot';
+import { WARN } from '.';
+import { languages } from './language-support';
+
+export const blockSchema = v.object({
+	name: v.string(),
+	category: v.string(),
+	localDependencies: v.array(v.string()),
+	dependencies: v.array(v.string()),
+	devDependencies: v.array(v.string()),
+	tests: v.boolean(),
+	/** Where to find the block relative to root */
+	directory: v.string(),
+	subdirectory: v.boolean(),
+	files: v.array(v.string()),
+});
+
+export const categorySchema = v.object({
+	name: v.string(),
+	blocks: v.array(blockSchema),
+});
+
+export type Category = v.InferInput<typeof categorySchema>;
+
+export type Block = v.InferInput<typeof blockSchema>;
+
+const TEST_SUFFIXES = ['.test.ts', '_test.ts', '.test.js', '_test.js'] as const;
+
+const isTestFile = (file: string): boolean =>
+	TEST_SUFFIXES.find((suffix) => file.endsWith(suffix)) !== undefined;
+
+/** Using the provided path to the blocks folder builds the blocks into categories and also resolves dependencies
+ *
+ * @param blocksPath
+ * @returns
+ */
+const buildBlocksDirectory = (blocksPath: string, cwd: string): Category[] => {
+	let paths: string[];
+
+	try {
+		paths = fs.readdirSync(blocksPath);
+	} catch {
+		program.error(color.red(`Couldn't read the ${color.bold(blocksPath)} directory.`));
+	}
+
+	const categories: Category[] = [];
+
+	for (const categoryPath of paths) {
+		const categoryDir = path.join(blocksPath, categoryPath);
+
+		if (fs.statSync(categoryDir).isFile()) continue;
+
+		const categoryName = path.basename(categoryPath);
+
+		const category: Category = {
+			name: categoryName,
+			blocks: [],
+		};
+
+		const files = fs.readdirSync(categoryDir);
+
+		for (const file of files) {
+			const blockDir = path.join(categoryDir, file);
+
+			if (fs.statSync(blockDir).isFile()) {
+				if (isTestFile(file)) continue;
+
+				const lang = languages.find((resolver) => resolver.matches(file));
+
+				if (!lang) {
+					console.warn(
+						`${WARN} Skipped \`${color.bold(blockDir)}\` \`${color.bold(
+							path.parse(file).ext
+						)}\` files are not currently supported!`
+					);
+					continue;
+				}
+
+				const name = path.parse(path.basename(file)).name;
+
+				// tries to find a test file with the same name as the file
+				const testsPath = files.find((f) =>
+					TEST_SUFFIXES.find((suffix) => f === `${name}${suffix}`)
+				);
+
+				const { dependencies, devDependencies, local } = lang
+					.resolveDependencies(blockDir, categoryName, false)
+					.match(
+						(val) => val,
+						(err) => {
+							program.error(color.red(err));
+						}
+					);
+
+				const block: Block = {
+					name,
+					directory: path.relative(cwd, categoryDir),
+					category: categoryName,
+					tests: testsPath !== undefined,
+					subdirectory: false,
+					files: [file],
+					localDependencies: local,
+					dependencies,
+					devDependencies,
+				};
+
+				if (testsPath !== undefined) {
+					block.files.push(testsPath);
+				}
+
+				category.blocks.push(block);
+			} else {
+				const blockName = file;
+
+				const blockFiles = fs.readdirSync(blockDir);
+
+				const hasTests = blockFiles.findIndex((f) => isTestFile(f)) !== -1;
+
+				const localDepsSet = new Set<string>();
+				const depsSet = new Set<string>();
+				const devDepsSet = new Set<string>();
+
+				// if it is a directory
+				for (const f of blockFiles) {
+					if (isTestFile(f)) continue;
+
+					const lang = languages.find((resolver) => resolver.matches(f));
+
+					if (!lang) {
+						console.warn(
+							`${WARN} Skipped \`${color.bold(path.join(blockDir, f))}\` \`${color.bold(
+								path.parse(file).ext
+							)}\` files are not currently supported!`
+						);
+						continue;
+					}
+
+					const { local, dependencies, devDependencies } = lang
+						.resolveDependencies(path.join(blockDir, f), categoryName, true)
+						.match(
+							(val) => val,
+							(err) => {
+								program.error(color.red(err));
+							}
+						);
+
+					for (const dep of local) {
+						localDepsSet.add(dep);
+					}
+
+					for (const dep of dependencies) {
+						depsSet.add(dep);
+					}
+
+					for (const dep of devDependencies) {
+						devDepsSet.add(dep);
+					}
+				}
+
+				const block: Block = {
+					name: blockName,
+					directory: path.relative(cwd, blockDir),
+					category: categoryName,
+					tests: hasTests,
+					subdirectory: true,
+					files: [...blockFiles],
+					localDependencies: Array.from(localDepsSet.keys()),
+					dependencies: Array.from(depsSet.keys()),
+					devDependencies: Array.from(devDepsSet.keys()),
+				};
+
+				category.blocks.push(block);
+			}
+		}
+
+		categories.push(category);
+	}
+
+	return categories;
+};
+
+const readCategories = (outputFilePath: string): Category[] =>
+	v.parse(v.array(categorySchema), JSON.parse(fs.readFileSync(outputFilePath).toString()));
+
+export { buildBlocksDirectory, readCategories, isTestFile };

package/src/utils/context.ts

@@ -0,0 +1,19 @@
+import type { Block, Category } from './build';
+
+export interface CLIContext {
+	/** The package.json of the CLI */
+	package: {
+		name: string;
+		version: string;
+		description: string;
+		repository: {
+			url: string;
+		};
+	};
+	/** Resolves the path relative to the root of the application
+	 *
+	 * @param path
+	 * @returns
+	 */
+	resolveRelativeToRoot: (path: string) => string;
+}

package/src/utils/diff.ts

@@ -0,0 +1,184 @@
+import color from 'chalk';
+import { type Change, diffChars } from 'diff';
+import { arraySum } from '../blocks/utilities/array-sum';
+import * as lines from '../blocks/utilities/lines';
+import { leftPadMin } from '../blocks/utilities/pad';
+
+type Options = {
+	/** The source file */
+	from: string;
+	/** The destination file */
+	to: string;
+	/** The changes to the file */
+	changes: Change[];
+	/** Expands all lines to show the entire file */
+	expand: boolean;
+	/** Maximum lines to show before collapsing */
+	maxUnchanged: number;
+	/** Color the removed lines */
+	colorRemoved?: (line: string) => string;
+	/** Color the added lines */
+	colorAdded?: (line: string) => string;
+	/** Prefixes each line with the string returned from this function. */
+	prefix: () => string;
+	intro: (options: Options) => string;
+	onUnchanged: (options: Options) => string;
+};
+
+const formatDiff = ({
+	from,
+	to,
+	changes,
+	expand = false,
+	maxUnchanged = 5,
+	colorRemoved = color.red,
+	colorAdded = color.green,
+	prefix,
+	onUnchanged,
+	intro,
+}: Options): string => {
+	let result = '';
+
+	const length = arraySum(changes, (change) => change.count ?? 0).toString().length + 1;
+
+	let lineOffset = 0;
+
+	if (changes.length === 1 && !changes[0].added && !changes[0].removed) {
+		return onUnchanged({
+			from,
+			to,
+			changes,
+			expand,
+			maxUnchanged,
+			colorAdded,
+			colorRemoved,
+			prefix,
+			onUnchanged,
+			intro,
+		});
+	}
+
+	result += intro({
+		from,
+		to,
+		changes,
+		expand,
+		maxUnchanged,
+		colorAdded,
+		colorRemoved,
+		prefix,
+		onUnchanged,
+		intro,
+	});
+
+	/** Provides the line number prefix */
+	const linePrefix = (line: number): string =>
+		color.gray(`${prefix?.() ?? ''}${leftPadMin(`${line + 1 + lineOffset} `, length)} `);
+
+	for (let i = 0; i < changes.length; i++) {
+		const change = changes[i];
+
+		const hasPreviousChange = changes[i - 1]?.added || changes[i - 1]?.removed;
+		const hasNextChange = changes[i + 1]?.added || changes[i + 1]?.removed;
+
+		if (!change.added && !change.removed) {
+			// show collapsed
+			if (!expand && change.count !== undefined && change.count > maxUnchanged) {
+				const prevLineOffset = lineOffset;
+				const ls = lines.get(change.value.trimEnd());
+
+				let shownLines = 0;
+
+				if (hasNextChange) shownLines += maxUnchanged;
+				if (hasPreviousChange) shownLines += maxUnchanged;
+
+				// just show all if we are going to show more than we have
+				if (shownLines >= ls.length) {
+					result += `${lines.join(ls, {
+						prefix: linePrefix,
+					})}\n`;
+					lineOffset += ls.length;
+					continue;
+				}
+
+				// this writes the top few lines
+				if (hasPreviousChange) {
+					result += `${lines.join(ls.slice(0, maxUnchanged), {
+						prefix: linePrefix,
+					})}\n`;
+				}
+
+				if (ls.length > shownLines) {
+					const count = ls.length - shownLines;
+					result += `${lines.join(
+						lines.get(
+							color.gray(
+								`+ ${count} more unchanged (${color.italic('-E to expand')})`
+							)
+						),
+						{
+							prefix: () => `${prefix?.() ?? ''}${leftPadMin(' ', length)} `,
+						}
+					)}\n`;
+				}
+
+				if (hasNextChange) {
+					lineOffset = lineOffset + ls.length - maxUnchanged;
+					result += `${lines.join(ls.slice(ls.length - maxUnchanged), {
+						prefix: linePrefix,
+					})}\n`;
+				}
+
+				// resets the line offset
+				lineOffset = prevLineOffset + change.count;
+				continue;
+			}
+
+			// show expanded
+
+			result += `${lines.join(lines.get(change.value.trimEnd()), {
+				prefix: linePrefix,
+			})}\n`;
+			lineOffset += change.count ?? 0;
+
+			continue;
+		}
+
+		const colorChange = (change: Change) => {
+			if (change.added) {
+				return colorAdded(change.value.trimEnd());
+			}
+
+			if (change.removed) {
+				return colorRemoved(change.value.trimEnd());
+			}
+
+			return change.value;
+		};
+
+		if (change.removed && change.count === 1) {
+			// single line change
+			const diffedChars = diffChars(change.value, changes[i + 1].value);
+
+			const sentence = diffedChars.map((chg) => colorChange(chg)).join('');
+
+			result += `${linePrefix(0)}${sentence}`;
+
+			lineOffset += 1;
+
+			i++;
+		} else {
+			result += `${lines.join(lines.get(colorChange(change)), {
+				prefix: linePrefix,
+			})}\n`;
+
+			if (!change.removed) {
+				lineOffset += change.count ?? 0;
+			}
+		}
+	}
+
+	return result;
+};
+
+export { formatDiff };

package/src/utils/get-installed-blocks.ts

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { Config } from '../config';
+import type { Block } from './build';
+
+type InstalledBlock = {
+	specifier: `${string}/${string}`;
+	path: string;
+};
+
+/** Finds installed blocks and returns them as `<category>/<name>`
+ *
+ * @param blocks
+ * @param config
+ * @returns
+ */
+const getInstalledBlocks = (blocks: Map<string, Block>, config: Config): InstalledBlock[] => {
+	const installedBlocks: InstalledBlock[] = [];
+
+	for (const [_, block] of blocks) {
+		const baseDir = path.join(config.path, block.category);
+
+		let blockPath = path.join(baseDir, block.files[0]);
+		if (block.subdirectory) {
+			blockPath = path.join(baseDir, block.name);
+		}
+
+		if (fs.existsSync(blockPath))
+			installedBlocks.push({
+				specifier: `${block.category}/${block.name}`,
+				path: blockPath,
+			});
+	}
+
+	return installedBlocks;
+};
+
+export { getInstalledBlocks };

package/src/utils/get-watermark.ts

@@ -0,0 +1,7 @@
+const getWatermark = (version: string, repoUrl: string): string => {
+	return `\tjsrepo ${version}\n\tInstalled from ${repoUrl}\n\t${new Date()
+		.toLocaleDateString()
+		.replaceAll('/', '-')}`;
+};
+
+export { getWatermark };

package/src/utils/git-providers.ts

@@ -0,0 +1,140 @@
+import { Octokit } from 'octokit';
+import * as v from 'valibot';
+import { Err, Ok, type Result } from '../blocks/types/result';
+import { type Category, categorySchema } from './build';
+import { OUTPUT_FILE } from './index';
+
+const octokit = new Octokit({});
+
+export type Info = {
+	refs: 'tags' | 'heads';
+	url: string;
+	name: string;
+	repoName: string;
+	owner: string;
+	ref: string;
+	provider: Provider;
+};
+
+export interface Provider {
+	/** Get the name of the provider
+	 *
+	 * @returns the name of the provider
+	 */
+	name: () => string;
+	/** Returns a URL to the raw path of the resource provided in the resourcePath
+	 *
+	 * @param repoPath
+	 * @param resourcePath
+	 * @returns
+	 */
+	resolveRaw: (repoPath: string | Info, resourcePath: string) => Promise<URL>;
+	/** Parses the url and gives info about the repo
+	 *
+	 * @param repoPath
+	 * @returns
+	 */
+	info: (repoPath: string) => Promise<Info>;
+	/** Returns true if this provider matches the provided url
+	 *
+	 * @param repoPath
+	 * @returns
+	 */
+	matches: (repoPath: string) => boolean;
+}
+
+/** Valid paths
+ *
+ *  `https://github.com/<owner>/<repo>/[tree]/[ref]`
+ *
+ *  `github/<owner>/<repo>/[tree]/[ref]`
+ */
+const github: Provider = {
+	name: () => 'github',
+	resolveRaw: async (repoPath, resourcePath) => {
+		let info: Info;
+		if (typeof repoPath === 'string') {
+			info = await github.info(repoPath);
+		} else {
+			info = repoPath;
+		}
+
+		return new URL(
+			resourcePath,
+			`https://raw.githubusercontent.com/${info.owner}/${info.repoName}/refs/${info.refs}/${info.ref}/`
+		);
+	},
+	info: async (repoPath) => {
+		const repo = repoPath.replaceAll(/(https:\/\/github.com\/)|(github\/)/g, '');
+
+		const [owner, repoName, ...rest] = repo.split('/');
+
+		let ref = 'main';
+
+		if (rest[0] === 'tree') {
+			ref = rest[1];
+		}
+
+		// checks if the type of the ref is tags or heads
+		let refs: 'heads' | 'tags' = 'heads';
+		// no need to check if ref is main
+		if (ref !== 'main') {
+			try {
+				const { data: tags } = await octokit.rest.git.listMatchingRefs({
+					owner,
+					repo: repoName,
+					ref: 'tags',
+				});
+
+				if (tags.some((tag) => tag.ref === `refs/tags/${ref}`)) {
+					refs = 'tags';
+				}
+			} catch {
+				refs = 'heads';
+			}
+		}
+
+		return {
+			refs,
+			url: repoPath,
+			name: github.name(),
+			repoName,
+			owner,
+			ref: ref,
+			provider: github,
+		};
+	},
+	matches: (repoPath) =>
+		repoPath.toLowerCase().startsWith('https://github.com') ||
+		repoPath.toLowerCase().startsWith('github'),
+};
+
+const getProviderInfo = async (repo: string): Promise<Result<Info, string>> => {
+	if (github.matches(repo)) {
+		return Ok(await github.info(repo));
+	}
+
+	return Err('Only GitHub repositories are supported at this time!');
+};
+
+const getManifest = async (url: URL): Promise<Result<Category[], string>> => {
+	try {
+		const response = await fetch(url);
+
+		if (!response.ok) {
+			return Err(
+				`There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+			);
+		}
+
+		const categories = v.parse(v.array(categorySchema), await response.json());
+
+		return Ok(categories);
+	} catch {
+		return Err(
+			`There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+		);
+	}
+};
+
+export { github, getProviderInfo, getManifest };

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+import color from 'chalk';
+
+export const OUTPUT_FILE = 'blocks-manifest.json';
+
+const WARN = color.bgRgb(245, 149, 66).white('WARN');
+
+const INFO = color.bgBlueBright.white('INFO');
+
+export { WARN, INFO };