juo 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/commands/publish/index.js

@@ -1,119 +1,198 @@
-import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { Flags } from '@oclif/core';
-import mime from 'mime';
-import fs from 'node:fs';
-import path from 'node:path';
-import asyncPool from 'tiny-async-pool';
-import { BaseCommand } from '../../base-command.js';
-export default class Publish extends BaseCommand {
-    static args = {};
-    static description = ' Publish theme files from the ./dist directory to the remote registry.';
-    static examples = [
-        `<%= config.bin %> publish
+import { Command, Flags } from "@oclif/core";
+import fs from "node:fs";
+import path from "node:path";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import mime from "mime";
+import asyncPool from "tiny-async-pool";
+import inquirer from "inquirer";
+
+//#region src/base-command.ts
+var BaseCommand = class extends Command {
+	static baseFlags = { reconfigure: Flags.boolean({
+		default: false,
+		description: "Reconfigure settings",
+		helpGroup: "GLOBAL"
+	}) };
+	args;
+	flags;
+	get configFileName() {
+		return "config.json";
+	}
+	get configFilePath() {
+		return path.join(this.config.configDir, this.configFileName);
+	}
+	configExists() {
+		return fs.existsSync(this.configFilePath);
+	}
+	async ensureConfig(reconfigure = false) {
+		let config = {};
+		if (this.configExists()) try {
+			config = this.loadConfig();
+			if (this.validateConfig(config) && !reconfigure) {
+				this.log(`Found configuration at ${this.configFilePath}`);
+				return config;
+			}
+		} catch {
+			this.log(`Warning: Could not parse existing config at ${this.configFilePath}`);
+		}
+		if (reconfigure && this.validateConfig(config)) this.log("Reconfiguring settings...");
+		else this.log("Configuration incomplete. Setting up...");
+		const questions = [];
+		if (!config.JUO_API_URL || reconfigure) questions.push({
+			default: "https://api.juo.io",
+			message: "Enter the Juo API URL:",
+			name: "JUO_API_URL",
+			type: "input",
+			validate(input) {
+				if (!input.trim()) return "Juo API URL is required";
+				return true;
+			}
+		});
+		if (!config.JUO_API_KEY || reconfigure) questions.push({
+			message: "Enter your Juo API key:",
+			name: "JUO_API_KEY",
+			type: "password",
+			validate(input) {
+				if (!input.trim()) return "Juo API key is required";
+				return true;
+			}
+		});
+		if (questions.length === 0) return config;
+		const response = await inquirer.prompt(questions);
+		if (response.JUO_API_URL) config.JUO_API_URL = response.JUO_API_URL.trim();
+		if (response.JUO_API_KEY) config.JUO_API_KEY = response.JUO_API_KEY.trim();
+		this.saveConfig(config);
+		this.log(`Saved configuration to ${this.configFilePath}`);
+		if (this.validateConfig(config)) return config;
+		throw new Error("Failed to create valid configuration");
+	}
+	async init() {
+		await super.init();
+		const { args, flags } = await this.parse({
+			args: this.ctor.args,
+			baseFlags: super.ctor.baseFlags,
+			flags: this.ctor.flags,
+			strict: this.ctor.strict
+		});
+		this.flags = flags;
+		this.args = args;
+	}
+	loadConfig() {
+		if (!this.configExists()) throw new Error(`Configuration file not found at ${this.configFilePath}`);
+		try {
+			const configContent = fs.readFileSync(this.configFilePath, "utf8");
+			return JSON.parse(configContent);
+		} catch (error) {
+			throw new Error(`Failed to parse configuration file at ${this.configFilePath}: ${error}`);
+		}
+	}
+	saveConfig(config) {
+		fs.mkdirSync(this.config.configDir, { recursive: true });
+		fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2), { encoding: "utf8" });
+	}
+	validateConfig(config) {
+		return Boolean(config.JUO_API_KEY && config.JUO_API_KEY.length > 0 && config.JUO_API_URL && config.JUO_API_URL.length > 0);
+	}
+};
+
+//#endregion
+//#region src/commands/publish/index.ts
+var Publish = class extends BaseCommand {
+	static args = {};
+	static description = " Publish theme files from the ./dist directory to the remote registry.";
+	static examples = [
+		`<%= config.bin %> publish
 Publish the default theme files.
 `,
-        `<%= config.bin %> publish --theme custom-theme
+		`<%= config.bin %> publish --theme custom-theme
 Publish a custom theme files.
 `,
-        `<%= config.bin %> publish --reconfigure
+		`<%= config.bin %> publish --reconfigure
 Reconfigure settings and publish.
-`,
-    ];
-    static flags = {
-        theme: Flags.string({
-            char: 't',
-            default: 'default',
-            description: 'Specify the name of the theme to publish',
-        }),
-    };
-    getAllFiles(dirPath, basePath) {
-        const files = [];
-        const items = fs.readdirSync(dirPath);
-        for (const item of items) {
-            const fullPath = path.join(dirPath, item);
-            const stat = fs.statSync(fullPath);
-            if (stat.isFile()) {
-                const relativePath = path.relative(basePath, fullPath);
-                files.push(relativePath);
-            }
-        }
-        return files;
-    }
-    async run() {
-        this.log(`🚀 Publishing ${this.flags.theme} theme files to registry...`);
-        try {
-            const config = await this.ensureConfig(this.flags.reconfigure);
-            this.log('📤 Uploading files...');
-            await this.uploadFiles(this.flags.theme, config);
-            this.log('✅ Publishing completed successfully!');
-        }
-        catch (error) {
-            this.error(`❌ Publishing failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async getAwsConnectionInfo(config, themeName) {
-        try {
-            // eslint-disable-next-line n/no-unsupported-features/node-builtins
-            const response = await fetch(`${config.JUO_API_URL}/get-publish-token`, {
-                body: JSON.stringify({ theme: themeName }),
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                    'X-Juo-Admin-Api-Key': config.JUO_API_KEY,
-                },
-                method: 'POST',
-            });
-            if (response.status !== 200) {
-                this.error(`API request failed with status ${response.status}`);
-            }
-            if (response.headers.get('Content-Type')?.includes('application/json')) {
-                return (await response.json());
-            }
-            return null;
-        }
-        catch (error) {
-            this.error(`Failed to fetch credentials: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async uploadFile(client, distDir, file, options) {
-        if (file.split('/').some((item) => item.startsWith('.'))) {
-            return file;
-        }
-        const filepath = path.join(distDir, file);
-        const stream = fs.createReadStream(filepath);
-        const command = new PutObjectCommand({
-            Body: stream,
-            Bucket: options.bucket,
-            CacheControl: 'max-age=3600, must-revalidate',
-            ContentType: mime.getType(file) || 'application/octet-stream',
-            Key: `${options.prefix}${file}`,
-        });
-        this.log(`📤 Uploading file '${file}'...`);
-        await client.send(command);
-        return file;
-    }
-    async uploadFiles(themeName, config) {
-        const connectionInfo = await this.getAwsConnectionInfo(config, themeName);
-        if (!connectionInfo) {
-            throw new Error('Failed to get AWS connection info');
-        }
-        const { bucket, credentials, prefix, region } = connectionInfo;
-        const client = new S3Client({
-            credentials,
-            region,
-        });
-        const distDir = path.resolve(process.cwd(), 'dist');
-        if (!fs.existsSync(distDir)) {
-            this.error('dist directory not found');
-        }
-        const files = this.getAllFiles(distDir, distDir);
-        if (files.length === 0) {
-            this.log('No files found in dist directory');
-            return;
-        }
-        this.log(`Found ${files.length} file(s) to upload`);
-        for await (const file of asyncPool(4, files, (file) => this.uploadFile(client, distDir, file, { bucket, prefix }))) {
-            this.log(`✅ Uploaded file '${file}'`);
-        }
-    }
-}
+`
+	];
+	static flags = { theme: Flags.string({
+		char: "t",
+		default: "default",
+		description: "Specify the name of the theme to publish"
+	}) };
+	getAllFiles(dirPath, basePath) {
+		const files = [];
+		const items = fs.readdirSync(dirPath);
+		for (const item of items) {
+			const fullPath = path.join(dirPath, item);
+			if (fs.statSync(fullPath).isFile()) {
+				const relativePath = path.relative(basePath, fullPath);
+				files.push(relativePath);
+			}
+		}
+		return files;
+	}
+	async run() {
+		this.log(`🚀 Publishing ${this.flags.theme} theme files to registry...`);
+		try {
+			const config = await this.ensureConfig(this.flags.reconfigure);
+			this.log("📤 Uploading files...");
+			await this.uploadFiles(this.flags.theme, config);
+			this.log("✅ Publishing completed successfully!");
+		} catch (error) {
+			this.error(`❌ Publishing failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async getAwsConnectionInfo(config, themeName) {
+		try {
+			const response = await fetch(`${config.JUO_API_URL}/merchant/get-publish-token`, {
+				body: JSON.stringify({ theme: themeName }),
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json",
+					"X-Juo-Access-Token": config.JUO_API_KEY
+				},
+				method: "POST"
+			});
+			if (response.status !== 200) this.error(`API request failed with status ${response.status}`);
+			if (response.headers.get("Content-Type")?.includes("application/json")) return await response.json();
+			return null;
+		} catch (error) {
+			this.error(`Failed to fetch credentials: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	async uploadFile(client, distDir, file, options) {
+		if (file.split("/").some((item) => item.startsWith("."))) return file;
+		const filepath = path.join(distDir, file);
+		const command = new PutObjectCommand({
+			Body: fs.createReadStream(filepath),
+			Bucket: options.bucket,
+			CacheControl: "max-age=3600, must-revalidate",
+			ContentType: mime.getType(file) || "application/octet-stream",
+			Key: `${options.prefix}${file}`
+		});
+		this.log(`📤 Uploading file '${file}'...`);
+		await client.send(command);
+		return file;
+	}
+	async uploadFiles(themeName, config) {
+		const connectionInfo = await this.getAwsConnectionInfo(config, themeName);
+		if (!connectionInfo) throw new Error("Failed to get AWS connection info");
+		const { bucket, credentials, prefix, region } = connectionInfo;
+		const client = new S3Client({
+			credentials,
+			region
+		});
+		const distDir = path.resolve(process.cwd(), "dist");
+		if (!fs.existsSync(distDir)) this.error("dist directory not found");
+		const files = this.getAllFiles(distDir, distDir);
+		if (files.length === 0) {
+			this.log("No files found in dist directory");
+			return;
+		}
+		this.log(`Found ${files.length} file(s) to upload`);
+		for await (const file of asyncPool(4, files, (file$1) => this.uploadFile(client, distDir, file$1, {
+			bucket,
+			prefix
+		}))) this.log(`✅ Uploaded file '${file}'`);
+	}
+};
+
+//#endregion
+export { Publish as default };

package/dist/generate-D7J6nPBd.js

@@ -0,0 +1,252 @@
+import { Command, Flags } from "@oclif/core";
+import { isCancel, log, select, spinner, text } from "@clack/prompts";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { detectPackageManager } from "nypm";
+import slugify from "slugify";
+import { Liquid } from "liquidjs";
+import { fileURLToPath } from "node:url";
+import { readPackageJSON } from "pkg-types";
+
+//#region src/utils/baseTemplateGenerator.ts
+var BaseTemplateGenerator = class {
+	renderTemplate(templateName, destDir, scope, fileFilter) {
+		try {
+			const templateDir = this.getTemplateDir(templateName);
+			const engine = new Liquid();
+			const files = this.getTemplateFiles(templateName);
+			const filteredFiles = fileFilter ? files.filter(fileFilter) : files;
+			for (const file of filteredFiles) {
+				const filename = engine.parseAndRenderSync(file, scope).replace(/\.liquid$/, "");
+				const tplPath = path.join(templateDir, file);
+				const destPath = path.join(destDir, filename);
+				mkdirSync(path.dirname(destPath), { recursive: true });
+				writeFileSync(destPath, engine.parseAndRenderSync(readFileSync(tplPath, "utf-8"), scope));
+			}
+		} catch (error) {
+			throw new Error(`Error rendering template ${templateName}: ${error}`);
+		}
+	}
+	getTemplateDir(name) {
+		const packageRoot = this.resolvePackageRoot();
+		return path.join(packageRoot, "templates", name);
+	}
+	getTemplateFiles(name) {
+		function scan(dirpath, baseDir) {
+			return readdirSync(dirpath).flatMap((filename) => {
+				const filepath = path.join(dirpath, filename);
+				if (statSync(filepath).isDirectory()) return scan(filepath, baseDir);
+				else return [path.relative(baseDir, filepath)];
+			});
+		}
+		const templateDir = this.getTemplateDir(name);
+		return scan(templateDir, templateDir);
+	}
+	resolvePackageRoot() {
+		let currentPath = path.dirname(fileURLToPath(import.meta.url));
+		while (!existsSync(path.join(currentPath, "package.json"))) {
+			const parentDir = path.dirname(currentPath);
+			if (parentDir === currentPath) throw new Error("Could not find package root");
+			currentPath = parentDir;
+		}
+		return currentPath;
+	}
+};
+
+//#endregion
+//#region src/utils/storyGenerator.ts
+var StoryGenerator = class extends BaseTemplateGenerator {
+	async generate(destDir, options) {
+		if (options.type === "block") await this.generateBlockTemplate(destDir, options);
+		else await this.generateThemeTemplate(destDir, options);
+	}
+	async generateBlockTemplate(destDir, options) {
+		const scope = { block: {
+			slug: slugify(options.name, { lower: true }),
+			name: options.name,
+			clsName: slugify(options.name, { lower: true }).split("-").map((item) => `${item[0].toUpperCase()}${item.substring(1)}`).join(""),
+			framework: options.framework
+		} };
+		if (["react", "preact"].includes(scope.block.framework)) {
+			if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+			this.renderTemplate("stories", destDir, scope);
+		} else options.logger?.("Story generation skipped");
+	}
+	async generateThemeTemplate(destDir, options) {
+		const themeScope = { theme: {
+			name: options.name,
+			slug: slugify(options.name, { lower: true }),
+			framework: options.framework,
+			clsName: slugify(options.name, { lower: true }).split("-").map((item) => `${item[0].toUpperCase()}${item.substring(1)}`).join("")
+		} };
+		if (options.framework === "react") this.renderTemplate("theme/react", destDir, themeScope, (filename) => filename.includes(".stories.tsx.liquid"));
+	}
+};
+
+//#endregion
+//#region src/utils/juoTemplateGenerator.ts
+var JuoTemplateGenerator = class extends BaseTemplateGenerator {
+	storyGenerator;
+	constructor() {
+		super();
+		this.storyGenerator = new StoryGenerator();
+	}
+	async generate(destDir, options) {
+		await this.generateBlockTemplate(destDir, options);
+	}
+	async generateBlockTemplate(destDir, options) {
+		const scope = { block: {
+			slug: slugify(options.name, { lower: true }),
+			name: options.name,
+			clsName: slugify(options.name, { lower: true }).split("-").map((item) => `${item[0].toUpperCase()}${item.substring(1)}`).join(""),
+			tailwind: options.tailwind,
+			framework: options.framework
+		} };
+		this.renderTemplate(`${options.type}/${options.framework}`, path.join(destDir, scope.block.slug), scope);
+		options.logger?.("Adding block to theme");
+		try {
+			appendFileSync(path.join(destDir, "index.ts"), `export { ${scope.block.clsName}Block } from "./${scope.block.slug}";\n`);
+		} catch (error) {
+			options.logger?.("Error adding block to theme: " + error);
+			throw error;
+		}
+		if (options.story) {
+			const projectRoot = path.dirname(path.dirname(destDir));
+			const storiesDir = path.join(projectRoot, "stories");
+			try {
+				await this.storyGenerator.generate(storiesDir, {
+					name: scope.block.name,
+					type: "block",
+					framework: options.framework,
+					tailwind: options.tailwind
+				});
+			} catch (error) {
+				options.logger?.("Error generating story: " + error);
+				throw error;
+			}
+		} else options.logger?.(`Story generation skipped (options.story = ${options.story})`);
+	}
+	appendStylesheet(destDir) {
+		this.renderTemplate("css", path.join(destDir, "src"), {});
+	}
+};
+
+//#endregion
+//#region src/utils/resolveFramework.ts
+async function resolveFramework() {
+	try {
+		const packageJson = await readPackageJSON();
+		if (!packageJson) throw new Error("Could not find package.json");
+		if (packageJson.dependencies == null) throw new Error("Could not find dependencies in package.json");
+		if ("preact" in packageJson.dependencies) return "preact";
+		return "react";
+	} catch (error) {
+		throw new Error(`Error resolving framework: ${error}`);
+	}
+}
+
+//#endregion
+//#region src/commands/generate.ts
+var Generate = class Generate extends Command {
+	static id = "generate";
+	static description = "Generate blocks for your project";
+	static flags = {
+		name: Flags.string({
+			char: "n",
+			description: "The name of the component"
+		}),
+		type: Flags.string({
+			description: "The type of the component",
+			options: ["block"],
+			default: "block"
+		}),
+		tailwind: Flags.boolean({
+			char: "t",
+			default: void 0,
+			allowNo: true
+		}),
+		verbose: Flags.boolean({
+			char: "v",
+			default: true,
+			allowNo: true
+		})
+	};
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+	resolvePackageJsonPath() {
+		let currentPath = path.resolve("./");
+		while (!existsSync(path.join(currentPath, "package.json"))) {
+			const parentDir = path.dirname(currentPath);
+			if (parentDir === currentPath) throw new Error("Could not find 'package.json' in the project");
+			currentPath = parentDir;
+		}
+		return currentPath;
+	}
+	async resolveCSSFramework(dir) {
+		try {
+			const packageJson = await readPackageJSON(path.join(dir, "package.json"));
+			if (packageJson?.dependencies?.tailwindcss || packageJson?.devDependencies?.tailwindcss) return "tailwind";
+			return false;
+		} catch (error) {
+			throw new Error(`Error resolving CSS framework: ${error}`);
+		}
+	}
+	async run() {
+		const { flags } = await this.parse(Generate);
+		let rootDir;
+		const templateGenerator = new JuoTemplateGenerator();
+		try {
+			rootDir = this.resolvePackageJsonPath();
+		} catch (error) {
+			throw new Error(`Error resolving package JSON path: ${error}`);
+		}
+		const tailwind = flags.tailwind ?? await this.resolveCSSFramework(rootDir);
+		if (isCancel(flags.type ?? await select({
+			message: "What you want to create?",
+			options: [
+				{
+					value: "block",
+					label: "Block"
+				},
+				{
+					value: "page",
+					label: "Page"
+				},
+				{
+					value: "theme",
+					label: "Theme"
+				}
+			],
+			initialValue: "block"
+		}))) process.exit(0);
+		const generateSpinner = flags.verbose ? spinner() : null;
+		const blocksDir = path.join(rootDir, "src/blocks");
+		const name = flags.name ?? await text({
+			message: "What is the name of the component?",
+			initialValue: "Starter Block",
+			validate(value) {
+				if (value.length === 0) return `Value is required!`;
+			}
+		});
+		if (isCancel(name)) this.exit(0);
+		const framework = await resolveFramework();
+		generateSpinner?.start();
+		generateSpinner?.message("Detecting package manager");
+		const packageManager = await detectPackageManager(rootDir);
+		if (!packageManager) throw new Error("Could not detect package manager");
+		if (flags.verbose) log.info("Package manager detected: " + packageManager.name);
+		generateSpinner?.message("Generating block");
+		await templateGenerator.generate(blocksDir, {
+			type: "block",
+			framework,
+			name,
+			tailwind,
+			logger: (msg) => generateSpinner?.message(msg),
+			story: true
+		});
+		templateGenerator.appendStylesheet(rootDir);
+		generateSpinner?.stop("Generated block");
+	}
+};
+
+//#endregion
+export { BaseTemplateGenerator as n, Generate as t };

package/dist/hooks/postrun.d.ts

@@ -0,0 +1,6 @@
+import { Hook } from "@oclif/core";
+
+//#region src/hooks/postrun.d.ts
+declare const hook: Hook.Postrun;
+//#endregion
+export { hook as default };

package/dist/hooks/postrun.js

@@ -0,0 +1,62 @@
+import { a as CUSTOMERIO_BETA_FORM_URL, i as CUSTOMERIO_API_KEY, n as trackCommandCompleted, o as CUSTOMERIO_SITE_ID, t as trackBetaSignup } from "../analytics-B2gwRg5Q.js";
+import { confirm, isCancel, text } from "@clack/prompts";
+import debug from "debug";
+
+//#region src/utils/betaSignup.ts
+const log$1 = debug("juo:betaSignup");
+async function sendToCustomerIO(email) {
+	if (!CUSTOMERIO_BETA_FORM_URL || !CUSTOMERIO_SITE_ID || !CUSTOMERIO_API_KEY) return;
+	try {
+		const basicAuth = Buffer.from(`${CUSTOMERIO_SITE_ID}:${CUSTOMERIO_API_KEY}`).toString("base64");
+		await fetch(CUSTOMERIO_BETA_FORM_URL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Basic ${basicAuth}`
+			},
+			body: JSON.stringify({ data: {
+				email,
+				source: "cli"
+			} })
+		}).catch((error) => {
+			log$1("Failed to send beta signup to CustomerIO: %O", error);
+		});
+	} catch (error) {
+		log$1("Error sending beta signup to CustomerIO: %O", error);
+	}
+}
+async function promptBetaSignup(commandContext) {
+	try {
+		const shouldSignup = await confirm({
+			message: "Would you like to request access to the private beta?",
+			initialValue: true
+		});
+		if (isCancel(shouldSignup) || !shouldSignup) return;
+		const email = await text({
+			message: "Enter your email address:",
+			placeholder: "your.email@example.com",
+			validate(value) {
+				if (value.length === 0) return "Email is required!";
+				if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return "Please enter a valid email address";
+			}
+		});
+		if (isCancel(email)) return;
+		sendToCustomerIO(email).catch((error) => {
+			log$1("Failed to send beta signup request: %O", error);
+		});
+		trackBetaSignup(email, commandContext);
+	} catch (error) {
+		log$1("Error in beta signup prompt: %O", error);
+	}
+}
+
+//#endregion
+//#region src/hooks/postrun.ts
+const hook = async function(options) {
+	if (options.Command) trackCommandCompleted(options.Command.id || options.Command.name || "unknown", true);
+	if (options.Command) await promptBetaSignup(options.Command.id || options.Command.name || "unknown");
+};
+var postrun_default = hook;
+
+//#endregion
+export { postrun_default as default };

package/dist/hooks/prerun.d.ts

@@ -0,0 +1,6 @@
+import { Hook } from "@oclif/core";
+
+//#region src/hooks/prerun.d.ts
+declare const hook: Hook.Prerun;
+//#endregion
+export { hook as default };

package/dist/hooks/prerun.js

@@ -0,0 +1,15 @@
+import { r as trackCommandStarted } from "../analytics-B2gwRg5Q.js";
+
+//#region src/hooks/prerun.ts
+const hook = async function(options) {
+	if (options.Command) {
+		const commandName = options.Command.id || options.Command.name || "unknown";
+		const properties = {};
+		if (options.argv && options.argv.length > 0) properties.argv = options.argv;
+		trackCommandStarted(commandName, properties);
+	}
+};
+var prerun_default = hook;
+
+//#endregion
+export { prerun_default as default };

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { run } from '@oclif/core';
+import { run } from "@oclif/core";
+export { run };

package/dist/index.js

@@ -1 +1,3 @@
-export { run } from '@oclif/core';
+import { run } from "@oclif/core";
+
+export { run };