@creact-labs/creact 0.1.0

package/dist/cli/output.js

@@ -0,0 +1,437 @@
+"use strict";
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiProgressBar = exports.ProgressBar = exports.Spinner = exports.colors = void 0;
+exports.formatDiff = formatDiff;
+exports.formatDeploymentStatus = formatDeploymentStatus;
+exports.formatResource = formatResource;
+exports.printSuccess = printSuccess;
+exports.printError = printError;
+exports.printWarning = printWarning;
+exports.printInfo = printInfo;
+exports.printHeader = printHeader;
+exports.printTable = printTable;
+/**
+ * CLI Output Utilities
+ *
+ * DEPRECATED: Most functions in this file are deprecated in favor of OutputManager.
+ * Use OutputManager (src/utils/Output.ts) for user-facing output instead.
+ *
+ * This file now only contains:
+ * - Color utilities (colors object)
+ * - Spinner, ProgressBar, MultiProgressBar classes (for backward compatibility)
+ *
+ * Deprecated functions (use OutputManager instead):
+ * - printSuccess() -> output.showSuccess()
+ * - printError() -> output.showError()
+ * - printInfo() -> output.showInfo()
+ * - printWarning() -> output.showWarning()
+ * - formatDiff() -> output.showPlanChanges()
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const Logger_1 = require("../utils/Logger");
+const logger = Logger_1.LoggerFactory.getLogger('cli');
+/**
+ * Color utilities for consistent CLI output
+ */
+exports.colors = {
+    // Status colors
+    success: chalk_1.default.green,
+    error: chalk_1.default.red,
+    warning: chalk_1.default.yellow,
+    info: chalk_1.default.blue,
+    // Diff colors (for plan command)
+    create: chalk_1.default.green,
+    update: chalk_1.default.yellow,
+    delete: chalk_1.default.red,
+    move: chalk_1.default.cyan,
+    // Semantic colors
+    primary: chalk_1.default.cyan,
+    secondary: chalk_1.default.gray,
+    highlight: chalk_1.default.bold.white,
+    dim: chalk_1.default.dim,
+    // Resource types
+    resource: chalk_1.default.magenta,
+    output: chalk_1.default.blue,
+    // Symbols
+    checkmark: chalk_1.default.green('✓'),
+    cross: chalk_1.default.red('✗'),
+    arrow: chalk_1.default.cyan('→'),
+    bullet: chalk_1.default.gray('•'),
+};
+/**
+ * Spinner manager for long-running operations
+ */
+class Spinner {
+    constructor(isJsonMode = false) {
+        this.spinner = null;
+        this.isJsonMode = false;
+        this.isJsonMode = isJsonMode;
+    }
+    /**
+     * Start spinner with message
+     */
+    start(message) {
+        if (this.isJsonMode) {
+            // In JSON mode, just log without spinner
+            logger.info(`[info] ${message}`);
+            return;
+        }
+        this.spinner = (0, ora_1.default)({
+            text: message,
+            color: 'cyan',
+        }).start();
+    }
+    /**
+     * Update spinner text
+     */
+    update(message) {
+        if (this.isJsonMode) {
+            logger.info(`[info] ${message}`);
+            return;
+        }
+        if (this.spinner) {
+            this.spinner.text = message;
+        }
+    }
+    /**
+     * Mark spinner as successful
+     */
+    succeed(message) {
+        if (this.isJsonMode) {
+            logger.info(`[success] ${message || 'Done'}`);
+            return;
+        }
+        if (this.spinner) {
+            this.spinner.succeed(message);
+            this.spinner = null;
+        }
+    }
+    /**
+     * Mark spinner as failed
+     */
+    fail(message) {
+        if (this.isJsonMode) {
+            logger.error(`[error] ${message || 'Failed'}`);
+            return;
+        }
+        if (this.spinner) {
+            this.spinner.fail(message);
+            this.spinner = null;
+        }
+    }
+    /**
+     * Mark spinner as warning
+     */
+    warn(message) {
+        if (this.isJsonMode) {
+            logger.warn(`[warning] ${message || 'Warning'}`);
+            return;
+        }
+        if (this.spinner) {
+            this.spinner.warn(message);
+            this.spinner = null;
+        }
+    }
+    /**
+     * Stop spinner without status
+     */
+    stop() {
+        if (this.spinner) {
+            this.spinner.stop();
+            this.spinner = null;
+        }
+    }
+}
+exports.Spinner = Spinner;
+/**
+ * Progress bar for batch operations
+ */
+class ProgressBar {
+    constructor(isJsonMode = false) {
+        this.bar = null;
+        this.isJsonMode = false;
+        this.total = 0;
+        this.current = 0;
+        this.isJsonMode = isJsonMode;
+    }
+    /**
+     * Start progress bar
+     */
+    start(total, startValue = 0, message) {
+        this.total = total;
+        this.current = startValue;
+        if (this.isJsonMode) {
+            logger.info(`[progress] ${message || 'Starting'} (0/${total})`);
+            return;
+        }
+        this.bar = new cli_progress_1.default.SingleBar({
+            format: `${message || 'Progress'} |${chalk_1.default.cyan('{bar}')}| {percentage}% | {value}/{total} | {status}`,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+            hideCursor: true,
+        });
+        this.bar.start(total, startValue, { status: '' });
+    }
+    /**
+     * Update progress
+     */
+    update(value, status) {
+        this.current = value;
+        if (this.isJsonMode) {
+            logger.info(`[progress] ${status || 'Processing'} (${value}/${this.total})`);
+            return;
+        }
+        if (this.bar) {
+            this.bar.update(value, { status: status || '' });
+        }
+    }
+    /**
+     * Increment progress by 1
+     */
+    increment(status) {
+        this.update(this.current + 1, status);
+    }
+    /**
+     * Stop progress bar
+     */
+    stop() {
+        if (this.bar) {
+            this.bar.stop();
+            this.bar = null;
+        }
+    }
+}
+exports.ProgressBar = ProgressBar;
+/**
+ * Multi-bar progress for parallel operations
+ */
+class MultiProgressBar {
+    constructor(isJsonMode = false) {
+        this.multibar = null;
+        this.bars = new Map();
+        this.isJsonMode = false;
+        this.isJsonMode = isJsonMode;
+        if (!isJsonMode) {
+            this.multibar = new cli_progress_1.default.MultiBar({
+                clearOnComplete: false,
+                hideCursor: true,
+                format: '{name} |{bar}| {percentage}% | {value}/{total}',
+            }, cli_progress_1.default.Presets.shades_classic);
+        }
+    }
+    /**
+     * Add a new progress bar
+     */
+    add(name, total, startValue = 0) {
+        if (this.isJsonMode) {
+            logger.info(`[progress] ${name}: 0/${total}`);
+            return;
+        }
+        if (this.multibar) {
+            const bar = this.multibar.create(total, startValue, { name });
+            this.bars.set(name, bar);
+        }
+    }
+    /**
+     * Update a specific progress bar
+     */
+    update(name, value) {
+        if (this.isJsonMode) {
+            return;
+        }
+        const bar = this.bars.get(name);
+        if (bar) {
+            bar.update(value);
+        }
+    }
+    /**
+     * Increment a specific progress bar
+     */
+    increment(name) {
+        if (this.isJsonMode) {
+            return;
+        }
+        const bar = this.bars.get(name);
+        if (bar) {
+            bar.increment();
+        }
+    }
+    /**
+     * Stop all progress bars
+     */
+    stop() {
+        if (this.multibar) {
+            this.multibar.stop();
+            this.multibar = null;
+            this.bars.clear();
+        }
+    }
+}
+exports.MultiProgressBar = MultiProgressBar;
+/**
+ * Format diff output with colors
+ * @deprecated Use OutputManager.showPlanChanges() and showPlanSummary() instead
+ */
+function formatDiff(changeSet) {
+    const lines = [];
+    // Header
+    lines.push(chalk_1.default.bold('\nPlanned Changes:\n'));
+    // Creates
+    if (changeSet.creates.length > 0) {
+        lines.push(exports.colors.create(`  + ${changeSet.creates.length} to create`));
+        changeSet.creates.forEach((node) => {
+            lines.push(exports.colors.create(`    + ${node.construct?.name || 'Unknown'}.${node.id}`));
+        });
+        lines.push('');
+    }
+    // Updates
+    if (changeSet.updates.length > 0) {
+        lines.push(exports.colors.update(`  ~ ${changeSet.updates.length} to update`));
+        changeSet.updates.forEach((node) => {
+            lines.push(exports.colors.update(`    ~ ${node.construct?.name || 'Unknown'}.${node.id}`));
+        });
+        lines.push('');
+    }
+    // Deletes
+    if (changeSet.deletes.length > 0) {
+        lines.push(exports.colors.delete(`  - ${changeSet.deletes.length} to delete`));
+        changeSet.deletes.forEach((node) => {
+            lines.push(exports.colors.delete(`    - ${node.construct?.name || 'Unknown'}.${node.id}`));
+        });
+        lines.push('');
+    }
+    // Moves
+    if (changeSet.moves && changeSet.moves.length > 0) {
+        lines.push(exports.colors.move(`  → ${changeSet.moves.length} to move`));
+        changeSet.moves.forEach((move) => {
+            lines.push(exports.colors.move(`    → ${move.from} → ${move.to}`));
+        });
+        lines.push('');
+    }
+    // Summary
+    const total = changeSet.creates.length +
+        changeSet.updates.length +
+        changeSet.deletes.length +
+        (changeSet.moves?.length || 0);
+    lines.push(chalk_1.default.bold(`Total: ${total} changes\n`));
+    return lines.join('\n');
+}
+/**
+ * Format deployment status with colors
+ */
+function formatDeploymentStatus(status) {
+    switch (status.toUpperCase()) {
+        case 'PENDING':
+            return exports.colors.info('PENDING');
+        case 'APPLYING':
+            return exports.colors.warning('APPLYING');
+        case 'DEPLOYED':
+            return exports.colors.success('DEPLOYED');
+        case 'FAILED':
+            return exports.colors.error('FAILED');
+        case 'ROLLED_BACK':
+            return exports.colors.warning('ROLLED_BACK');
+        default:
+            return exports.colors.dim(status);
+    }
+}
+/**
+ * Format resource output
+ */
+function formatResource(construct, id, status) {
+    const resourceStr = `${exports.colors.resource(construct)}.${exports.colors.highlight(id)}`;
+    if (status) {
+        return `${resourceStr} ${exports.colors.dim('→')} ${formatDeploymentStatus(status)}`;
+    }
+    return resourceStr;
+}
+/**
+ * Print success message
+ * @deprecated Use OutputManager.showSuccess() instead
+ */
+function printSuccess(message) {
+    console.log(`${exports.colors.checkmark} ${exports.colors.success(message)}`);
+}
+/**
+ * Print error message
+ * @deprecated Use OutputManager.showError() instead
+ */
+function printError(message) {
+    console.error(`${exports.colors.cross} ${exports.colors.error(message)}`);
+}
+/**
+ * Print warning message
+ * @deprecated Use OutputManager.showWarning() instead
+ */
+function printWarning(message) {
+    console.log(`${exports.colors.warning('⚠')} ${exports.colors.warning(message)}`);
+}
+/**
+ * Print info message
+ * @deprecated Use OutputManager.showInfo() instead
+ */
+function printInfo(message) {
+    console.log(`${exports.colors.info('ℹ')} ${exports.colors.info(message)}`);
+}
+/**
+ * Print section header
+ * @deprecated Use OutputManager methods instead
+ */
+function printHeader(message) {
+    console.log(`\n${exports.colors.highlight(message)}`);
+    console.log(exports.colors.dim('─'.repeat(message.length)));
+}
+/**
+ * Print table
+ * @deprecated Use OutputManager methods instead
+ */
+function printTable(headers, rows) {
+    // Calculate column widths
+    const widths = headers.map((header, i) => {
+        const maxRowWidth = Math.max(...rows.map((row) => (row[i] || '').length));
+        return Math.max(header.length, maxRowWidth);
+    });
+    // Print header
+    const headerRow = headers.map((header, i) => header.padEnd(widths[i])).join('  ');
+    console.log(exports.colors.highlight(headerRow));
+    console.log(exports.colors.dim('─'.repeat(headerRow.length)));
+    // Print rows
+    rows.forEach((row) => {
+        const rowStr = row.map((cell, i) => (cell || '').padEnd(widths[i])).join('  ');
+        console.log(rowStr);
+    });
+}

package/dist/cli/utils.d.ts

@@ -0,0 +1,59 @@
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+/**
+ * CLI utility functions
+ *
+ * Shared utilities for CLI commands including config loading,
+ * logging, and error handling.
+ */
+import type { CLIContext } from './core/CLIContext';
+/**
+ * Log message if verbose mode is enabled
+ *
+ * @param message - Message to log
+ * @param verbose - Whether verbose mode is enabled
+ */
+export declare function logVerbose(message: string, verbose?: boolean): void;
+/**
+ * Format error for CLI output
+ *
+ * @param error - Error to format
+ * @param verbose - Whether to include stack trace
+ * @returns Formatted error message
+ */
+export declare function formatError(error: Error, verbose?: boolean): string;
+/**
+ * Output data in JSON format if --json flag is set
+ *
+ * @param data - Data to output
+ * @param ctx - Command context
+ * @returns true if JSON output was used, false otherwise
+ */
+export declare function outputJson(data: any, ctx: CLIContext): boolean;

package/dist/cli/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logVerbose = logVerbose;
+exports.formatError = formatError;
+exports.outputJson = outputJson;
+const output_1 = require("./output");
+const Logger_1 = require("../utils/Logger");
+const logger = Logger_1.LoggerFactory.getLogger('cli');
+/**
+ * Log message if verbose mode is enabled
+ *
+ * @param message - Message to log
+ * @param verbose - Whether verbose mode is enabled
+ */
+function logVerbose(message, verbose = false) {
+    if (verbose || process.env.CREACT_VERBOSE === 'true') {
+        logger.debug(output_1.colors.dim(`[verbose] ${message}`));
+    }
+}
+/**
+ * Format error for CLI output
+ *
+ * @param error - Error to format
+ * @param verbose - Whether to include stack trace
+ * @returns Formatted error message
+ */
+function formatError(error, verbose = false) {
+    let message = output_1.colors.error(`Error: ${error.message}`);
+    if (verbose && error.stack) {
+        message += `\n\n${output_1.colors.dim('Stack trace:')}\n${output_1.colors.dim(error.stack)}`;
+    }
+    return message;
+}
+/**
+ * Output data in JSON format if --json flag is set
+ *
+ * @param data - Data to output
+ * @param ctx - Command context
+ * @returns true if JSON output was used, false otherwise
+ */
+function outputJson(data, ctx) {
+    if (ctx.flags.json) {
+        logger.info(JSON.stringify(data, null, 2));
+        return true;
+    }
+    return false;
+}

package/dist/context/createContext.d.ts

@@ -0,0 +1,90 @@
+/**
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+
+ * you may not use this file except in compliance with the License.
+
+ * You may obtain a copy of the License at
+
+ *
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ *
+
+ * Unless required by applicable law or agreed to in writing, software
+
+ * distributed under the License is distributed on an "AS IS" BASIS,
+
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+ * See the License for the specific language governing permissions and
+
+ * limitations under the License.
+
+ *
+
+ * Copyright 2025 Daniel Coutinho Ribeiro
+
+ */
+/**
+ * Context object returned by createContext
+ * Contains Provider and Consumer components for sharing values down the component tree
+ */
+export interface Context<T> {
+    /** Unique symbol to identify this context */
+    _contextId: symbol;
+    /** Default value when no Provider is found */
+    defaultValue?: T;
+    /** Provider component to supply context value */
+    Provider: (props: {
+        value: T;
+        children?: any;
+    }) => any;
+    /** Consumer component to consume context value (alternative to useContext) */
+    Consumer: (props: {
+        children: (value: T) => any;
+    }) => any;
+}
+/**
+ * Create a typed context object (like React.createContext)
+ *
+ * Returns a context object with Provider and Consumer components.
+ * Use with useContext hook to access values from the nearest Provider.
+ *
+ * REQ-02: Stack Context (declarative outputs)
+ *
+ * @param defaultValue - Optional default value when no Provider exists
+ * @returns Context object with Provider and Consumer
+ *
+ * @example
+ * ```tsx
+ * // Create a typed context
+ * interface RegistryOutputs {
+ *   repositoryUrl?: string;
+ *   repositoryArn?: string;
+ * }
+ *
+ * const RegistryContext = createContext<RegistryOutputs>({});
+ *
+ * // Provider component
+ * function RegistryStack({ children }) {
+ *   const repo = useInstance(EcrRepository, { key: 'repo', name: 'my-app' });
+ *   const [repositoryUrl, setRepositoryUrl] = useState();
+ *   const [repositoryArn, setRepositoryArn] = useState();
+ *
+ *   const outputs = { repositoryUrl, repositoryArn };
+ *   return <RegistryContext.Provider value={outputs}>{children}</RegistryContext.Provider>;
+ * }
+ *
+ * // Consumer component
+ * function Service() {
+ *   const { repositoryUrl } = useContext(RegistryContext);
+ *   const service = useInstance(AppRunnerService, {
+ *     image: `${repositoryUrl}:latest`
+ *   });
+ *   return <></>;
+ * }
+ * ```
+ */
+export declare function createContext<T>(defaultValue?: T): Context<T>;