@mapples/cli 0.0.1 → 0.0.2

package/dist/commands/style.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Synchronizes style from the API
+ */
+export declare const syncStyle: () => Promise<void>;
+/**
+ * Shows information about style in a table format
+ */
+export declare const showStyleInfo: () => Promise<void>;

package/dist/index.js

@@ -71636,7 +71636,7 @@ const projectService = (axiosInstance) => {
 
 const styleService = (axiosInstance) => {
     const get = async () => {
-        const { data } = await axiosInstance.get('/public/style');
+        const { data } = await axiosInstance.get('/public/styles');
         return data;
     };
     return {
@@ -71685,7 +71685,7 @@ const fetchPages = async () => {
  * Creates a directory if it doesn't exist
  * @param dirPath The directory path
  */
-const ensureDirectoryExists = (dirPath) => {
+const ensureDirectoryExists$1 = (dirPath) => {
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
@@ -71722,7 +71722,7 @@ const createPageFromTemplates = (pageName, pageData, config) => {
     const templateDir = path.resolve(__dirname, '../templates/PageTemplate');
     const destDir = path.join(process.cwd(), config.sourceDir, config.pagesDir, pageName);
     // Ensure the destination directory exists
-    ensureDirectoryExists(destDir);
+    ensureDirectoryExists$1(destDir);
     // Get all files in the template directory
     const templateFiles = fs.readdirSync(templateDir);
     // Process each template file
@@ -71924,6 +71924,227 @@ const showPagesInfo = async () => {
     }
 };
 
+/**
+ * Fetches style from the API
+ * @returns Style data
+ */
+const fetchStyle = async () => {
+    try {
+        return await services.style.get();
+    }
+    catch (error) {
+        console.error('Error fetching style:', error);
+        throw error;
+    }
+};
+/**
+ * Creates a directory if it doesn't exist
+ * @param dirPath The directory path
+ */
+const ensureDirectoryExists = (dirPath) => {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+};
+/**
+ * Creates a .donotedit file in the style directory
+ * @param styleDir The style directory path
+ */
+const createDonotEditFile = (styleDir) => {
+    const donotEditPath = path.join(styleDir, '.donotedit');
+    if (!fs.existsSync(donotEditPath)) {
+        fs.writeFileSync(donotEditPath, '');
+    }
+};
+/**
+ * Synchronizes style from the API
+ */
+const syncStyle = async () => {
+    try {
+        // Read the configuration
+        const config = readConfig();
+        if (!config) {
+            console.error('Configuration not found. Run "mapples init" first.');
+            process.exit(1);
+        }
+        console.log('Fetching style...');
+        // Fetch style from the API
+        const style = await fetchStyle();
+        // Create style directory
+        const styleDir = path.join(process.cwd(), config.sourceDir, 'style');
+        ensureDirectoryExists(styleDir);
+        // Create .donotedit file
+        createDonotEditFile(styleDir);
+        // Save style.json with the transformed structure
+        const styleJsonPath = path.join(styleDir, 'style.json');
+        const styleConfig = {
+            themeConfig: style.theme?.data || {},
+            typographyConfig: style.typography?.data || {},
+            sizingConfig: style.sizing?.data || {},
+        };
+        writeJsonToFile(styleJsonPath, styleConfig);
+        // Save _meta_style.json with response data excluding the data keys
+        const metaStylePath = path.join(styleDir, '_meta_style.json');
+        const metaData = lodashExports.cloneDeep(style);
+        // Remove data from theme, sizing, and typography
+        if (metaData.theme && metaData.theme.data) {
+            lodashExports.unset(metaData.theme, 'data');
+        }
+        if (metaData.sizing && metaData.sizing.data) {
+            lodashExports.unset(metaData.sizing, 'data');
+        }
+        if (metaData.typography && metaData.typography.data) {
+            lodashExports.unset(metaData.typography, 'data');
+        }
+        writeJsonToFile(metaStylePath, metaData);
+        console.log('Style synchronized successfully.');
+    }
+    catch (error) {
+        console.error('Error synchronizing style:', error);
+        process.exit(1);
+    }
+};
+/**
+ * Shows information about style in a table format
+ */
+const showStyleInfo = async () => {
+    try {
+        console.log('Fetching style...');
+        // Read the configuration
+        const config = readConfig();
+        if (!config) {
+            console.error('Configuration not found. Run "mapples init" first.');
+            process.exit(1);
+        }
+        // Fetch style from the API
+        const style = await fetchStyle();
+        // Check style directory and files
+        const styleDir = path.join(process.cwd(), config.sourceDir, 'style');
+        const styleJsonPath = path.join(styleDir, 'style.json');
+        const metaStylePath = path.join(styleDir, '_meta_style.json');
+        // Define style components
+        const styleComponents = [
+            { name: 'theme', data: style.theme },
+            { name: 'typography', data: style.typography },
+            { name: 'sizing', data: style.sizing },
+        ];
+        // Determine status for each component
+        const componentStatuses = styleComponents.map((component) => {
+            if (!fs.existsSync(styleDir)) {
+                return { status: 'New', color: 'white', icon: '🆕' };
+            }
+            else if (!fs.existsSync(styleJsonPath) || !fs.existsSync(metaStylePath)) {
+                return { status: 'New', color: 'white', icon: '🆕' };
+            }
+            else {
+                try {
+                    // Read and parse meta file
+                    const metaContent = fs.readFileSync(metaStylePath, 'utf-8');
+                    const metaData = JSON.parse(metaContent);
+                    // Compare updatedAt timestamps
+                    const metaComponent = metaData[component.name];
+                    const apiComponent = component.data;
+                    if (!metaComponent || !apiComponent) {
+                        return { status: 'New', color: 'white', icon: '🆕' };
+                    }
+                    if (metaComponent.updated_at === apiComponent.updated_at) {
+                        return { status: 'Synced', color: 'green', icon: '✅ ' };
+                    }
+                    else {
+                        return { status: 'Update', color: 'yellow', icon: '⚠️' };
+                    }
+                }
+                catch (error) {
+                    console.error(`Error reading meta file for ${component.name}:`, error);
+                    return { status: 'Error', color: 'red', icon: '❌' };
+                }
+            }
+        });
+        // Calculate column widths for better formatting
+        const nameWidth = Math.max(4, ...styleComponents.map((c) => c.name.length));
+        const uuidWidth = Math.max(4, ...styleComponents.map((c) => c.data?.uuid?.length || 0));
+        const createdAtWidth = Math.max(9, ...styleComponents.map((c) => c.data?.created_at?.length || 0));
+        const updatedAtWidth = Math.max(9, ...styleComponents.map((c) => c.data?.updated_at?.length || 0));
+        const statusWidth = Math.max(6, ...componentStatuses.map((s) => (s.icon + s.status).length)) + 3;
+        // Print table header
+        console.log('┌' +
+            '─'.repeat(nameWidth + 2) +
+            '┬' +
+            '─'.repeat(statusWidth + 2) +
+            '┬' +
+            '─'.repeat(createdAtWidth + 2) +
+            '┬' +
+            '─'.repeat(updatedAtWidth + 2) +
+            '┬' +
+            '─'.repeat(uuidWidth + 2) +
+            '┐');
+        console.log('│ ' +
+            'name'.padEnd(nameWidth) +
+            ' │ ' +
+            'status'.padEnd(statusWidth) +
+            ' │ ' +
+            'createdAt'.padEnd(createdAtWidth) +
+            ' │ ' +
+            'updatedAt'.padEnd(updatedAtWidth) +
+            ' │ ' +
+            'uuid'.padEnd(uuidWidth) +
+            ' │');
+        console.log('├' +
+            '─'.repeat(nameWidth + 2) +
+            '┼' +
+            '─'.repeat(statusWidth + 2) +
+            '┼' +
+            '─'.repeat(createdAtWidth + 2) +
+            '┼' +
+            '─'.repeat(updatedAtWidth + 2) +
+            '┼' +
+            '─'.repeat(uuidWidth + 2) +
+            '┤');
+        // Helper function to truncate text if it's too long
+        const truncate = (text, maxLength) => {
+            if (text.length <= maxLength)
+                return text;
+            return text.substring(0, maxLength - 3) + '...';
+        };
+        // Print table rows for each component
+        styleComponents.forEach((component, index) => {
+            const status = componentStatuses[index];
+            const statusText = status.icon + status.status;
+            const visibleStatusLength = statusText.length;
+            const coloredStatus = chalk[status.color](statusText);
+            const statusPadding = ' '.repeat(Math.max(0, statusWidth - visibleStatusLength));
+            console.log('│ ' +
+                component.name.padEnd(nameWidth) +
+                ' │ ' +
+                coloredStatus +
+                statusPadding +
+                ' │ ' +
+                truncate(component.data?.created_at || '', createdAtWidth).padEnd(createdAtWidth) +
+                ' │ ' +
+                truncate(component.data?.updated_at || '', updatedAtWidth).padEnd(updatedAtWidth) +
+                ' │ ' +
+                truncate(component.data?.uuid || '', uuidWidth).padEnd(uuidWidth) +
+                ' │');
+        });
+        // Print table footer
+        console.log('└' +
+            '─'.repeat(nameWidth + 2) +
+            '┴' +
+            '─'.repeat(statusWidth + 2) +
+            '┴' +
+            '─'.repeat(createdAtWidth + 2) +
+            '┴' +
+            '─'.repeat(updatedAtWidth + 2) +
+            '┴' +
+            '─'.repeat(uuidWidth + 2) +
+            '┘');
+    }
+    catch (error) {
+        console.error('Error fetching style info:', error);
+        process.exit(1);
+    }
+};
+
 const program = new Command();
 program.name('mapples').description('Mapples CLI').version('0.0.0');
 program
@@ -71982,5 +72203,27 @@ program
         process.exit(1);
     }
 });
+program
+    .command('style')
+    .description('Manage Mapples style')
+    .option('--sync', 'Synchronize style from the API')
+    .option('--info', 'Show information about style')
+    .action(async (options) => {
+    try {
+        if (options.sync) {
+            await syncStyle();
+        }
+        else if (options.info) {
+            await showStyleInfo();
+        }
+        else {
+            console.log('Please specify an option: --sync, --info');
+        }
+    }
+    catch (error) {
+        console.error('Error managing style:', error);
+        process.exit(1);
+    }
+});
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map