@weme-ui/weme-ui 0.1.5 → 0.2.1

package/dist/project-BZkWl9YJ.js

@@ -0,0 +1,685 @@
+import { a as DEFAULT_REGISTRY_NAME, i as DEFAULT_REGISTRY_BRANCH, n as DEFAULT_PATHS, o as PROJECT_CONFIG_FILENAME, r as DEFAULT_REGISTRIES, s as PROJECT_LOCKFILE_FILENAME, t as CLI_TMP_DIR } from "./index.js";
+import { basename, isAbsolute, join, relative, resolve } from "node:path/posix";
+import { cwd, exit } from "node:process";
+import makeFetch from "make-fetch-happen";
+import { LOCKFILE_SCHEMA_URL, ProjectConfigSchema, ProjectLockFileSchema, RegistryConfigSchema } from "@weme-ui/schema";
+import { defu } from "defu";
+import { hash } from "hasha";
+import { addDependency } from "nypm";
+import * as v from "valibot";
+import { existsSync, mkdirSync } from "node:fs";
+import fs from "node:fs/promises";
+import { parseURL } from "ufo";
+
+// src/utils/fetcher.ts
+const fetch = makeFetch.defaults({
+	cachePath: CLI_TMP_DIR,
+	noProxy: ["raw.githubusercontent.com"]
+});
+/**
+* Fetch a URL.
+*
+* @param url - The URL to fetch.
+* @returns The text response.
+*/
+async function fetchURL(url) {
+	return (await fetch(url)).text();
+}
+/**
+* Fetch a JSON file.
+*
+* @param url - The URL to fetch.
+* @returns The JSON response.
+*/
+async function fetchJSON(url) {
+	return (await fetch(url)).json();
+}
+
+// src/utils/registry.ts
+var Registry = class {
+	/**
+	* The name of the registry.
+	*/
+	name;
+	/**
+	* The branch of the registry.
+	*/
+	branch;
+	/**
+	* The cache of the registry.
+	*/
+	cache = null;
+	constructor(name, branch) {
+		this.name = name;
+		this.branch = branch;
+	}
+	/**
+	* Get the registry metadata.
+	*
+	* @returns The registry metadata.
+	*/
+	async metadata() {
+		const { config } = await this.load();
+		return {
+			name: config.name,
+			description: config.description,
+			version: config.version,
+			homepage: config.homepage,
+			repository: config.repository,
+			issues: config.issues,
+			contributors: config.contributors,
+			access: config.access
+		};
+	}
+	/**
+	* Get the registry dependencies.
+	*
+	* @returns The registry dependencies.
+	*/
+	async dependencies() {
+		return (await this.load()).config.dependencies ?? [];
+	}
+	/**
+	* Get the registry dev dependencies.
+	*
+	* @returns The registry dev dependencies.
+	*/
+	async devDependencies() {
+		return (await this.load()).config.devDependencies ?? [];
+	}
+	/**
+	* Find the items in the registry.
+	*
+	* @param filter - The filter function.
+	* @returns The items that match the filter.
+	*/
+	async getItems(filter) {
+		const { config, index } = await this.load();
+		const items = filter ? config.items.filter(filter) : config.items;
+		const visited = /* @__PURE__ */ new Set();
+		const result = [];
+		const visit = (item) => {
+			if (visited.has(item.name)) return;
+			visited.add(item.name);
+			for (const name of item.registryDependencies ?? []) {
+				const dep = index.get(name);
+				if (!dep) continue;
+				visit(dep);
+			}
+			result.push(item);
+		};
+		items.forEach(visit);
+		return result;
+	}
+	/**
+	* Get the files of an item.
+	*
+	* @param item - The item to get the files from.
+	* @returns The resolved files of the item.
+	*/
+	async getItemFiles(item) {
+		return await Promise.all(item.files.map(async (file) => {
+			const result = await this.getItemFileContent(file.path);
+			return {
+				type: file.type,
+				kind: file.kind,
+				path: file.path,
+				target: file.target,
+				content: result.content,
+				hash: result.hash
+			};
+		}));
+	}
+	/**
+	* Get the content of a file.
+	*
+	* @param source - The source of the file.
+	* @returns The content of the file.
+	*/
+	async getItemFileContent(source) {
+		const url = this.joinURL(source);
+		const content = await fetchURL(url);
+		return {
+			content,
+			hash: await hash(content)
+		};
+	}
+	/**
+	* Load the registry cache.
+	*
+	* @throws If the registry cache fails to load.
+	* @returns The registry cache.
+	*/
+	async load() {
+		this.cache ??= this.fetchRegistryJson().catch((err) => {
+			this.cache = null;
+			throw err;
+		});
+		return this.cache;
+	}
+	/**
+	* Fetch the registry JSON.
+	*
+	* @throws If the registry JSON fails to parse.
+	* @returns The registry cache.
+	*/
+	async fetchRegistryJson() {
+		const url = this.joinURL("registry.json");
+		const raw = await fetchJSON(url);
+		const parsed = v.safeParse(RegistryConfigSchema, raw);
+		if (!parsed.success) throw new Error("Failed to parse registry config", { cause: parsed.issues });
+		const config = parsed.output;
+		const index = /* @__PURE__ */ new Map();
+		for (const item of config.items) {
+			if (index.has(item.name)) throw new Error(`Duplicate item name: ${item.name}`);
+			index.set(item.name, item);
+		}
+		return {
+			config,
+			index
+		};
+	}
+	/**
+	* Join the URL with the name and branch.
+	*
+	* @param path The path to join.
+	* @returns The joined URL.
+	*/
+	joinURL(path) {
+		return `https://raw.githubusercontent.com/${this.name}/refs/heads/${this.branch}/${path}`;
+	}
+};
+/**
+* Use the registry.
+*
+* @param name The name of the registry.
+* @param branch The branch of the registry.
+* @returns The registry instance.
+*/
+function useRegistry(name, branch = DEFAULT_REGISTRY_BRANCH) {
+	return new Registry(name, branch);
+}
+
+// src/utils/utilities.ts
+/**
+* Ensure the working directory.
+*
+* @param path - The working directory to ensure.
+* @returns The ensured working directory. If the directory does not exist, it will be created.
+*/
+function ensureDir(path) {
+	if (path === cwd()) return path;
+	const resolved = resolve(path);
+	if (!existsSync(resolved)) mkdirSync(resolved, { recursive: true });
+	return resolved;
+}
+/**
+* Check if a file exists.
+*
+* @param root - The root directory of the project.
+* @param filename - The name of the file.
+* @returns Whether the file exists.
+*/
+async function existsFile(root, filename) {
+	const filePath = resolve(root, filename);
+	const exists = existsSync(filePath);
+	if (!exists) return false;
+	const content = await fs.readFile(filePath, "utf-8");
+	return exists && content !== null && content.trim() !== "";
+}
+/**
+* Read a file.
+*
+* @param root - The root directory of the project.
+* @param filename - The name of the file.
+* @returns The content of the file. If the file does not exist, it will return `null`.
+*/
+async function readFile(root, filename) {
+	try {
+		if (!await existsFile(root, filename)) return null;
+		const content = await fs.readFile(join(ensureDir(root), filename), "utf-8");
+		if (!content) return null;
+		return content;
+	} catch {
+		return null;
+	}
+}
+/**
+* Write a file.
+*
+* @param root - The root directory of the project.
+* @param filename - The name of the file.
+* @param content - The content of the file.
+* @returns Whether the file was written successfully.
+*/
+async function writeFile(root, filename, content) {
+	try {
+		const path = join(ensureDir(root), filename);
+		await fs.writeFile(path, `${content}\n`, {
+			encoding: "utf-8",
+			flag: "w"
+		});
+	} catch {
+		return false;
+	}
+	return true;
+}
+/**
+* Parse a repository URL.
+*
+* @param url - The URL to parse.
+* @returns The parsed repository URL.
+*/
+function parseRepoURL(url) {
+	if (!url) return {
+		name: DEFAULT_REGISTRY_NAME,
+		branch: DEFAULT_REGISTRY_BRANCH
+	};
+	const { host, pathname, hash } = parseURL(url);
+	if (host && host !== "github.com" || !pathname) throw new Error(`Invalid repository URL: ${url}`);
+	let branch = hash ? hash.replace(/^#/, "") : DEFAULT_REGISTRY_BRANCH;
+	let name = removeLeadingSlash(pathname);
+	if (name.split("/").length !== 2 && name.includes("/tree/")) {
+		branch = name.split("/tree/")[1];
+		name = name.split("/tree/")[0];
+	}
+	return {
+		name,
+		branch
+	};
+}
+/**
+* Remove the leading slash from a path.
+*
+* @param path - The path to remove the leading slash from.
+* @returns The path without the leading slash.
+*/
+function removeLeadingSlash(path) {
+	return path.replace(/^\//, "");
+}
+/**
+* Unwrap an error.
+*
+* @param error - The error to unwrap.
+* @returns The unwrapped error.
+*/
+function unwrapError(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+/**
+* Call a callback when a condition is met.
+*
+* @param condition - The condition to check.
+* @param callback - The callback to call.
+* @param finalizer - The finalizer to call.
+* @returns Whether the callback was called successfully.
+*/
+async function callWhen(condition, callback, finalizer) {
+	if (condition) try {
+		await callback();
+	} catch (e) {
+		console.error(unwrapError(e));
+		exit(1);
+	} finally {
+		if (finalizer) await finalizer();
+	}
+}
+/**
+* Generate a random color.
+*
+* @returns The random color.
+*/
+function randomColor() {
+	const colors = [
+		"black",
+		"red",
+		"green",
+		"yellow",
+		"blue",
+		"magenta",
+		"cyan",
+		"white",
+		"gray"
+	];
+	return colors[Math.floor(Math.random() * colors.length)];
+}
+
+// src/utils/project.ts
+/**
+* Project management class.
+*
+* @example
+* ```ts
+* const project = new Project(cwd)
+* ```
+*
+* @param root - The root directory of the project.
+* @returns The project instance.
+*/
+var Project = class {
+	/**
+	* The root directory of the project.
+	*/
+	root;
+	constructor(root) {
+		this.root = root;
+	}
+	/**
+	* Get the project info.
+	*
+	* @returns The project info.
+	*/
+	async info() {
+		const config = await this.hasProjectConfig() ? await this.loadProjectConfig() : null;
+		return {
+			root: this.root,
+			paths: this.resolvePaths(config?.paths),
+			registries: config?.registries ?? DEFAULT_REGISTRIES,
+			defaultRegistry: config?.registries?.[0] ?? DEFAULT_REGISTRIES[0]
+		};
+	}
+	/**
+	* Add an item to the project.
+	*
+	* @param name - The name of the item to add.
+	* @returns Whether the item was added.
+	*/
+	async addItem(name, kinds = ["file"]) {
+		if (await this.hasAddedItem(name)) return await this.updateItem(name);
+		const parsed = await this.parseItemName(name);
+		const registry = useRegistry(parsed.registry);
+		const items = await registry.getItems((item) => item.name === parsed.name);
+		if (items.length === 0) throw new Error(`Item ${parsed.name} not found in the registry ${parsed.registry}`);
+		const { paths, registries, defaultRegistry } = await this.info();
+		const itemRegistry = registries.find((registry) => registry.registry === parsed.registry) ?? defaultRegistry;
+		const addedItems = [];
+		for (const item of items) {
+			const files = await registry.getItemFiles(item);
+			const addedItem = {
+				name: item.name,
+				type: item.type,
+				registry: itemRegistry.registry,
+				repo: itemRegistry.repo,
+				prefix: itemRegistry.prefix,
+				files: []
+			};
+			for (const file of files) {
+				if (!kinds.includes(file.kind)) continue;
+				const fileName = basename(file.path);
+				const fileDir = paths[file.type] ?? paths["~"];
+				let filePath = fileDir;
+				if (file.type === "component") filePath = itemRegistry.prefix ? join(fileDir, itemRegistry.prefix, item.name) : join(fileDir, item.name);
+				await writeFile(this.joinPath(filePath), fileName, file.content);
+				addedItem.files.push({
+					kind: file.kind,
+					source: file.path,
+					dest: join(filePath, fileName)
+				});
+			}
+			if (addedItem.files.length > 0) addedItems.push(addedItem);
+		}
+		if (addedItems.length === 0) return false;
+		const lockfile = await this.loadLockfile() ?? {
+			$schema: LOCKFILE_SCHEMA_URL,
+			items: []
+		};
+		lockfile.items.push(...addedItems);
+		const written = await writeFile(join(this.root, CLI_TMP_DIR), PROJECT_LOCKFILE_FILENAME, JSON.stringify(lockfile, null, 2));
+		const dependencies = items.map((item) => item.dependencies ?? []).flat();
+		const devDependencies = items.map((item) => item.devDependencies ?? []).flat();
+		if (dependencies.length > 0) await this.addDependencies(dependencies);
+		if (devDependencies.length > 0) await this.addDevDependencies(devDependencies);
+		const cssVariables = items.map((item) => item.cssVars ?? {}).reduce((acc, curr) => defu(acc, curr), {});
+		if (Object.keys(cssVariables).length > 0) await this.addCssVariables(cssVariables);
+		return written;
+	}
+	/**
+	* Update an added item by name in the project.
+	*
+	* @param name - The name of the item to update.
+	* @returns Whether the item was updated.
+	*/
+	async updateItem(name) {
+		return false;
+	}
+	/**
+	* Add css variables to the project.
+	*
+	* @param cssVariables - The css variables to add.
+	* @throws If the project config is not found.
+	* @throws If the project config is not writable.
+	*/
+	async addCssVariables(cssVariables) {
+		const projectConfig = await this.loadProjectConfig();
+		if (!projectConfig) throw new Error("Project config not found");
+		projectConfig.unocss = projectConfig.unocss ?? {};
+		projectConfig.unocss.cssVars = defu(projectConfig.unocss.cssVars ?? {}, cssVariables);
+		await writeFile(this.root, PROJECT_CONFIG_FILENAME, JSON.stringify(projectConfig, null, 2));
+	}
+	/**
+	* Check if an item was added to the project.
+	*
+	* @param name - The name of the item to check.
+	* @returns Whether the item was added.
+	*/
+	async hasAddedItem(name) {
+		const lockfile = await this.loadLockfile();
+		if (lockfile) {
+			const parsed = await this.parseItemName(name);
+			return lockfile.items.some((item) => item.name === parsed.name && item.registry === parsed.registry);
+		}
+		return false;
+	}
+	/**
+	* Get the files of an added item.
+	*
+	* @param itemName - The name of the item to get the files from.
+	* @returns The resolved files of the item.
+	* @throws If the item is not found in the lockfile.
+	* @throws If the file is not found in the project.
+	*/
+	async getAddedItemFiles(itemName) {
+		const lockfile = await this.loadLockfile();
+		if (lockfile) {
+			const addedItem = lockfile.items.find((item) => item.name === itemName);
+			if (!addedItem) throw new Error(`Item ${itemName} not found in the lockfile`);
+			return await Promise.all(addedItem.files.map(async (file) => {
+				const result = await this.getAddedItemFileContent(file.dest);
+				return {
+					type: addedItem.type,
+					registry: addedItem.registry,
+					repo: addedItem.repo,
+					prefix: addedItem.prefix,
+					kind: file.kind,
+					source: file.source,
+					dest: file.dest,
+					content: result.content,
+					hash: result.hash
+				};
+			}));
+		}
+		return [];
+	}
+	/**
+	* Get the content of an added item file by filepath.
+	*
+	* @param filepath - The filepath of the file.
+	* @returns The content of the file.
+	* @throws If the file is not found in the project.
+	*/
+	async getAddedItemFileContent(filepath) {
+		const content = await readFile(this.root, filepath);
+		if (!content) throw new Error(`File ${filepath} not found in the project`);
+		return {
+			content,
+			hash: await hash(content)
+		};
+	}
+	/**
+	* Add dependencies to the project.
+	*
+	* @param dependencies - The dependencies to add.
+	*/
+	async addDependencies(dependencies) {
+		await addDependency(dependencies, {
+			cwd: this.root,
+			silent: true
+		});
+	}
+	/**
+	* Add dev dependencies to the project.
+	*
+	* @param dependencies - The dev dependencies to add.
+	*/
+	async addDevDependencies(dependencies) {
+		await addDependency(dependencies, {
+			cwd: this.root,
+			silent: true,
+			dev: true
+		});
+	}
+	/**
+	* Check if the project is initialized.
+	*
+	* @returns Whether the project is initialized.
+	*/
+	async isInitialized() {
+		const checkList = [
+			this.joinPath("uno.config.ts"),
+			this.joinPath(PROJECT_CONFIG_FILENAME),
+			this.joinPath(CLI_TMP_DIR, PROJECT_LOCKFILE_FILENAME),
+			this.joinPath("package.json"),
+			this.joinPath(CLI_TMP_DIR, "uno.config.ts")
+		];
+		return (await Promise.all(checkList.map(async (path) => await existsFile(this.root, path)))).every(Boolean);
+	}
+	/**
+	* Check if the project has a package.json file.
+	*
+	* @returns Whether the project has a package.json file.
+	*/
+	async hasPackageJson() {
+		return await existsFile(this.root, "package.json");
+	}
+	/**
+	* Check if the project has a project config file.
+	*
+	* @returns Whether the project has a project config file.
+	*/
+	async hasProjectConfig() {
+		return await existsFile(this.root, PROJECT_CONFIG_FILENAME);
+	}
+	/**
+	* Check if the project has a lockfile.
+	*
+	* @returns Whether the project has a lockfile.
+	*/
+	async hasLockfile() {
+		return await existsFile(this.root, join(CLI_TMP_DIR, PROJECT_LOCKFILE_FILENAME));
+	}
+	/**
+	* Check if the project has a uno config file.
+	*
+	* @returns Whether the project has a uno config file.
+	*/
+	async hasUnoConfig() {
+		return await existsFile(this.root, join(CLI_TMP_DIR, "uno.config.ts"));
+	}
+	/**
+	* Load the project config file.
+	*
+	* @returns The loaded project config if it exists, otherwise null.
+	*/
+	async loadProjectConfig() {
+		const content = await readFile(this.root, PROJECT_CONFIG_FILENAME);
+		if (content) try {
+			const configJson = JSON.parse(content);
+			const parsed = v.safeParse(ProjectConfigSchema, configJson);
+			if (parsed.success) return parsed.output;
+			return null;
+		} catch {}
+		return null;
+	}
+	/**
+	* Load the lockfile.
+	*
+	* @returns The loaded lockfile if it exists, otherwise null.
+	*/
+	async loadLockfile() {
+		const content = await readFile(join(this.root, CLI_TMP_DIR), PROJECT_LOCKFILE_FILENAME);
+		if (content) try {
+			const lockfileJson = JSON.parse(content);
+			const parsed = v.safeParse(ProjectLockFileSchema, lockfileJson);
+			if (parsed.success) return parsed.output;
+		} catch {}
+		return null;
+	}
+	/**
+	* Resolve project config paths to locations relative to the project root.
+	*
+	* @param paths - The paths from project config.
+	* @returns The resolved paths.
+	*/
+	resolvePaths(paths) {
+		const merged = defu(paths ?? {}, DEFAULT_PATHS);
+		const alias = this.toProjectRelative(this.root, merged["~"]);
+		return Object.fromEntries(Object.entries(merged).map(([key, value]) => [key, key === "~" ? alias : this.toProjectRelative(this.root, this.expandTildeAlias(value, alias))]));
+	}
+	/**
+	* Expand a tilde alias.
+	*
+	* @param value - The value to expand.
+	* @param alias - The alias to expand.
+	* @returns The expanded value.
+	*/
+	expandTildeAlias(value, alias) {
+		if (value === "~") return alias;
+		if (value.startsWith("~/")) {
+			const rest = value.slice(2);
+			return rest ? join(alias, rest) : alias;
+		}
+		return value;
+	}
+	/**
+	* Convert a path to a project relative path.
+	*
+	* @param root - The project root directory.
+	* @param path - The path to convert.
+	* @returns The project relative path.
+	*/
+	toProjectRelative(root, path) {
+		const abs = isAbsolute(path) ? resolve(path) : resolve(root, path);
+		if (abs === root || abs.startsWith(`${root}/`)) return relative(root, abs) || ".";
+		return abs;
+	}
+	/**
+	* Parse the item name.
+	*
+	* @param input - The item name to parse, format: `<registry>/<item-name>`.
+	* @returns The parsed item name.
+	*/
+	async parseItemName(input) {
+		const s = input.trim().replace(/\/+$/, "");
+		const i = s.lastIndexOf("/");
+		if (i === -1) return {
+			registry: (await this.info()).defaultRegistry.registry,
+			name: s
+		};
+		return {
+			registry: s.slice(0, i),
+			name: s.slice(i + 1)
+		};
+	}
+	/**
+	* Join a path to the workplace directory.
+	*
+	* @param paths - The paths to join.
+	* @returns The joined path.
+	*/
+	joinPath(...paths) {
+		return join(this.root, ...paths.map(removeLeadingSlash));
+	}
+};
+
+export { parseRepoURL as a, writeFile as c, existsFile as i, useRegistry as l, callWhen as n, randomColor as o, ensureDir as r, unwrapError as s, Project as t };
+//# sourceMappingURL=project-BZkWl9YJ.js.map