@contentstorage/core 2.2.0 → 3.0.1

package/dist/commands/cli.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { pullContent } from './pull.js';
 import { generateTypes } from './generate-types.js';
 import { showStats } from './stats.js';
+import { captureScreenshot } from './screenshot.js';
 const COMMANDS = {
     pull: {
         name: 'pull',
@@ -37,6 +38,15 @@ const COMMANDS = {
             '  --pending-changes      Analyze pending/draft content',
         ],
     },
+    screenshot: {
+        name: 'screenshot',
+        description: 'Open browser in live-editor mode for screenshots',
+        usage: 'contentstorage screenshot --url <url> [options]',
+        options: [
+            '  --url <url>            Dev server URL (e.g., http://localhost:3000)',
+            '  --content-key <key>    Content key for your project',
+        ],
+    },
 };
 function showHelp() {
     console.log(chalk.bold('\nContentstorage CLI'));
@@ -99,6 +109,9 @@ async function main() {
         case 'stats':
             await showStats();
             break;
+        case 'screenshot':
+            await captureScreenshot();
+            break;
         default:
             console.error(chalk.red(`Unknown command: ${command}\n`));
             console.log(chalk.dim('Run "contentstorage --help" for usage'));

package/dist/commands/screenshot.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function captureScreenshot(): Promise<void>;

package/dist/commands/screenshot.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { exec } from 'child_process';
+import chalk from 'chalk';
+import { loadConfig } from '../core/config-loader.js';
+export async function captureScreenshot() {
+    console.log(chalk.blue('Starting screenshot mode...'));
+    // Parse CLI arguments
+    const config = await parseArguments();
+    // Validate configuration
+    if (!validateConfig(config)) {
+        process.exit(1);
+    }
+    // Build URL with live-editor params
+    const liveEditorUrl = buildLiveEditorUrl(config.url, config.contentKey);
+    console.log(chalk.blue(`Opening browser with live-editor mode...`));
+    console.log(chalk.dim(`URL: ${liveEditorUrl}`));
+    // Open in default browser
+    openInBrowser(liveEditorUrl);
+    console.log(chalk.green('\nBrowser opened successfully!'));
+    console.log(chalk.dim('Use the Contentstorage UI to capture screenshots.'));
+}
+async function parseArguments() {
+    const args = process.argv.slice(2);
+    const cliConfig = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.substring(2);
+            const value = args[i + 1];
+            if (value && !value.startsWith('--')) {
+                if (key === 'url') {
+                    cliConfig.url = value;
+                }
+                else if (key === 'content-key') {
+                    cliConfig.contentKey = value;
+                }
+                i++;
+            }
+        }
+    }
+    // Load file config for contentKey fallback
+    let fileConfig = {};
+    try {
+        fileConfig = await loadConfig();
+    }
+    catch {
+        console.log(chalk.yellow('Could not load configuration file. Using CLI arguments only.'));
+    }
+    return {
+        url: cliConfig.url || '',
+        contentKey: cliConfig.contentKey || fileConfig.contentKey,
+    };
+}
+function validateConfig(config) {
+    if (!config.url) {
+        console.error(chalk.red('Error: --url argument is required.'));
+        console.log(chalk.dim('Usage: contentstorage screenshot --url http://localhost:3000'));
+        console.log(chalk.dim('       contentstorage screenshot --url http://localhost:5173'));
+        return false;
+    }
+    try {
+        new URL(config.url);
+    }
+    catch {
+        console.error(chalk.red(`Error: Invalid URL format: ${config.url}`));
+        return false;
+    }
+    if (!config.contentKey) {
+        console.error(chalk.red('Error: content-key is required.'));
+        console.log(chalk.dim('Provide via --content-key or in contentstorage.config.js'));
+        return false;
+    }
+    return true;
+}
+function buildLiveEditorUrl(baseUrl, contentKey) {
+    const url = new URL(baseUrl);
+    url.searchParams.set('contentstorage_live_editor', 'true');
+    url.searchParams.set('screenshot_mode', 'true');
+    if (contentKey) {
+        url.searchParams.set('contentstorage_key', contentKey);
+    }
+    return url.toString();
+}
+function openInBrowser(url) {
+    const platform = process.platform;
+    let command;
+    if (platform === 'darwin') {
+        command = `open "${url}"`;
+    }
+    else if (platform === 'win32') {
+        command = `start "" "${url}"`;
+    }
+    else {
+        command = `xdg-open "${url}"`;
+    }
+    exec(command, (error) => {
+        if (error) {
+            console.error(chalk.red(`Failed to open browser: ${error.message}`));
+            console.log(chalk.yellow(`Please open this URL manually: ${url}`));
+        }
+    });
+}

package/dist/utils/browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Find Chrome executable on the system
+ * @returns Path to Chrome executable or null if not found
+ */
+export declare function findChrome(): string | null;
+/**
+ * Get helpful error message when Chrome is not found
+ */
+export declare function getChromeNotFoundMessage(): string;

package/dist/utils/browser.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Common Chrome installation paths by platform
+ */
+const CHROME_PATHS = {
+    darwin: [
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    ],
+    win32: [
+        'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+        'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        process.env.LOCALAPPDATA
+            ? path.join(process.env.LOCALAPPDATA, 'Google\\Chrome\\Application\\chrome.exe')
+            : '',
+    ].filter(Boolean),
+    linux: [
+        '/usr/bin/google-chrome',
+        '/usr/bin/google-chrome-stable',
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+        '/snap/bin/chromium',
+    ],
+};
+/**
+ * Find Chrome executable on the system
+ * @returns Path to Chrome executable or null if not found
+ */
+export function findChrome() {
+    const platform = process.platform;
+    const paths = CHROME_PATHS[platform] || [];
+    for (const chromePath of paths) {
+        if (chromePath && fs.existsSync(chromePath)) {
+            return chromePath;
+        }
+    }
+    return null;
+}
+/**
+ * Get helpful error message when Chrome is not found
+ */
+export function getChromeNotFoundMessage() {
+    const platform = process.platform;
+    const installInstructions = {
+        darwin: 'Download from https://www.google.com/chrome/ or install via: brew install --cask google-chrome',
+        win32: 'Download from https://www.google.com/chrome/',
+        linux: 'Install via: sudo apt install google-chrome-stable (Debian/Ubuntu) or sudo dnf install google-chrome-stable (Fedora)',
+    };
+    return `Chrome not found on your system.
+
+Searched locations:
+${(CHROME_PATHS[platform] || []).map((p) => `  - ${p}`).join('\n')}
+
+To install Chrome:
+  ${installInstructions[platform] || 'Download from https://www.google.com/chrome/'}`;
+}

package/dist/utils/flatten-json.d.ts

@@ -1 +1 @@
-export declare function flattenJson(data: any, prefix?: string, result?: Record<string, any>): Record<string, any>;
+export declare function flattenJson(data: any, prefix?: string, result?: Record<string, string>): Record<string, string>;

package/dist/utils/flatten-json.js

@@ -1,56 +1,21 @@
 export function flattenJson(data, prefix = '', result = {}) {
-    const stopFlatteningIfKeyExists = 'contentstorage_type';
-    // Check if the current data is an object that should not be flattened further
-    if (typeof data === 'object' &&
-        data !== null &&
-        !Array.isArray(data) && // Must be an object, not an array
-        Object.prototype.hasOwnProperty.call(data, stopFlatteningIfKeyExists)) {
-        if (prefix) {
-            // If there's a prefix, this object is nested. Assign it directly.
-            result[prefix] = data;
-        }
-        else {
-            // This is the root object itself having the 'stopFlatteningIfKeyExists' key.
-            // Consistent with how root primitives are handled (result remains empty),
-            // we don't add it to the result if there's no prefix. The function's
-            // purpose is to flatten *into* key-value pairs. If the root itself
-            // is one of these "don't flatten" types, 'result' will remain empty,
-            // which is consistent with the original function's behavior for root primitives.
-        }
-    }
-    else if (typeof data === 'object' && data !== null) {
-        // It's an object or array that should be processed further
+    if (typeof data === 'object' && data !== null) {
         if (Array.isArray(data)) {
-            if (data.length === 0 && prefix) {
-                // Handle empty arrays if prefix exists
-                result[prefix] = [];
-            }
             data.forEach((item, index) => {
-                // Recursively call, the check for 'stopFlatteningIfKeyExists' will apply to 'item'
                 flattenJson(item, prefix ? `${prefix}.${index}` : `${index}`, result);
             });
         }
         else {
-            let isEmptyObject = true;
             for (const key in data) {
                 if (Object.prototype.hasOwnProperty.call(data, key)) {
-                    isEmptyObject = false;
                     const newPrefix = prefix ? `${prefix}.${key}` : key;
-                    // Recursively call, the check for 'stopFlatteningIfKeyExists' will apply to 'data[key]'
                     flattenJson(data[key], newPrefix, result);
                 }
             }
-            if (isEmptyObject && prefix) {
-                // Handle empty objects (that were not 'special') if prefix exists
-                result[prefix] = {};
-            }
         }
     }
     else if (prefix) {
-        result[prefix] = data;
+        result[prefix] = String(data);
     }
-    // If the initial data is a primitive and prefix is empty, result remains empty.
-    // If the initial data is a 'special' object (contains 'stopFlatteningIfKeyExists')
-    // and prefix is empty, result also remains empty based on the logic above.
     return result;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaido@contentstorage.app>",
   "homepage": "https://contentstorage.app",
-  "version": "2.2.0",
+  "version": "3.0.1",
   "type": "module",
   "description": "Contentstorage CLI for managing translations and generating TypeScript types",
   "license": "MIT",
@@ -23,7 +23,7 @@
     "release": "npx release-it"
   },
   "dependencies": {
-    "axios": "^1.7.2",
+    "axios": "^1.13.2",
     "chalk": "^4.1.2",
     "pluralize": "^8.0.0"
   },