tessl/npm-ice--app

A universal framework based on React.js that provides scripts and configuration for web development with zero-config support for ES6+, TypeScript, routing, state management, and multi-platform deployment.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Ice.js (@ice/app)

Name: tessl/npm-ice--app
Author: tessl

Ice.js is a universal framework based on React.js that provides scripts and configuration for web development with zero-config support for ES6+, TypeScript, routing, state management, and multi-platform deployment (web, miniapp, Weex). It offers comprehensive tooling, a plugin system, development server with hot reloading, and optimized build processes for scalable application development.

Package Information

Package Name: @ice/app
Package Type: npm
Language: TypeScript
Installation: npm install @ice/app --save-dev

Core Imports

import { defineConfig } from "@ice/app";

For configuration types:

import type { UserConfig } from "@ice/app";

For service creation:

import createService from "@ice/app/service";

For code analysis:

import { analyzeImports, scanImports, getFileExports } from "@ice/app/analyze";

For logging utilities:

import { logger, createLogger } from "@ice/app";

For Express types (for mock functionality):

import type { Request, Response } from "@ice/app";

Basic Usage

// ice.config.ts
import { defineConfig } from "@ice/app";

export default defineConfig({
  // Development server configuration
  server: {
    host: 'localhost',
    port: 3000
  },
  // Module aliases
  alias: {
    '@': './src'
  },
  // Build output configuration
  outputDir: 'dist',
  // Enable TypeScript checking
  tsChecker: true,
  // CSS modules configuration
  cssModules: {
    localIdentName: '[name]__[local]--[hash:base64:5]'
  },
  // Routing configuration
  routes: {
    ignoreFiles: ['**/components/**']
  }
});

Architecture

Ice.js is built around several key architectural components:

Service Layer: Core build and development services managed by createService
Configuration System: Comprehensive configuration through defineConfig with TypeScript support
CLI Interface: Command-line tools for build and start operations with extensive options
Plugin System: Extensible architecture supporting custom plugins for build pipeline customization
Code Analysis: Static analysis tools for import/export discovery and dependency scanning
Multi-platform Support: Unified development experience targeting web, miniapps, and Weex platforms
Zero Configuration: Smart defaults requiring minimal setup while maintaining full customizability

Capabilities

Configuration Management

Define and manage comprehensive framework configuration with full TypeScript support and validation.

function defineConfig(config: UserConfig | (() => UserConfig)): UserConfig;

interface UserConfig {
  alias?: Record<string, string>;
  outputDir?: string;
  publicPath?: string;
  devPublicPath?: string;
  hash?: boolean | string;
  externals?: Record<string, string> | string[];
  define?: Record<string, any>;
  plugins?: Plugin[];
  routes?: RoutesConfig;
  server?: ServerConfig;
  ssr?: boolean;
  ssg?: boolean;
  proxy?: Record<string, ProxyConfig>;
  mock?: MockConfig | boolean;
  cssModules?: CSSModulesConfig | boolean;
  postcss?: PostCSSConfig;
  optimization?: OptimizationConfig;
  experimental?: ExperimentalConfig;
  // ... and many more options
}

Configuration

Command Line Interface

Powerful CLI for development and build operations with extensive configuration options and multi-platform support.

// CLI Commands
ice build [options]    // Build project for production
ice start [options]    // Start development server

// Key Options
--target <target>      // Build target: 'web', 'weex', miniapp platforms
--mode <mode>         // Build mode: 'development' | 'production'  
--config <config>     // Custom config file path
--host <host>         // Development server host
--port <port>         // Development server port
--analyzer            // Bundle size analysis
--speedup             // Rust-based build optimization

Command Line Interface

Service Management

Create and manage Ice.js service instances for programmatic build and development operations.

function createService(options: CreateServiceOptions): Promise<{ run: () => Promise<any> }>;

interface CreateServiceOptions {
  rootDir: string;
  command: 'start' | 'build' | 'test';
  commandArgs: CommandArgs;
}

Service Management

Code Analysis

Static analysis utilities for dependency scanning, import analysis, and export discovery in JavaScript/TypeScript projects.

function analyzeImports(files: string[], options: AnalyzeOptions): Promise<Set<string> | false>;
function scanImports(entries: string[], options?: ScanOptions): Promise<Record<string, DepScanData>>;
function getFileExports(options: FileExportOptions): Promise<string[]>;

Code Analysis

Logging Utilities

Namespaced logging system with debug controls for development and production environments.

function createLogger(namespace?: string): Logger;

interface Logger {
  fatal(message: any, ...args: any[]): void;
  error(message: any, ...args: any[]): void;
  warn(message: any, ...args: any[]): void;
  log(message: any, ...args: any[]): void;
  info(message: any, ...args: any[]): void;
  start(message: any, ...args: any[]): void;
  success(message: any, ...args: any[]): void;
  ready(message: any, ...args: any[]): void;
  debug(message: any, ...args: any[]): void;
  trace(message: any, ...args: any[]): void;
  briefError(message: any, ...args: any[]): void;
}

const logger: Logger;

Logging Utilities

Test Configuration

Helpers for configuring Jest and Vitest with Ice.js framework defaults and optimizations.

function defineJestConfig(userConfig: JestConfig | (() => Promise<JestConfig>)): () => Promise<JestConfig>;
function defineVitestConfig(userConfig: UserConfigExport): UserConfigFn;

Test Configuration

Core Types

interface UserConfig {
  // Build configuration
  outputDir?: string;
  publicPath?: string;
  hash?: boolean | string;
  minify?: boolean | MinifyOptions;
  sourceMap?: boolean | string;
  
  // Development configuration  
  devPublicPath?: string;
  proxy?: Record<string, ProxyConfig>;
  mock?: MockConfig | boolean;
  
  // Module configuration
  alias?: Record<string, string>;
  externals?: Record<string, string> | string[];
  compileDependencies?: string[];
  define?: Record<string, any>;
  
  // Framework configuration
  routes?: RoutesConfig;
  ssr?: boolean;
  ssg?: boolean;
  server?: ServerConfig;
  plugins?: Plugin[];
  
  // Build optimization
  optimization?: OptimizationConfig;
  codeSplitting?: boolean | string;
  crossOriginLoading?: string;
  
  // Developer experience
  tsChecker?: boolean;
  eslint?: boolean | ESLintConfig;
  cssModules?: boolean | CSSModulesConfig;
  postcss?: PostCSSConfig;
  
  // Advanced configuration
  experimental?: ExperimentalConfig;
  transform?: TransformConfig;
  syntaxFeatures?: SyntaxFeatures;
}

interface CreateServiceOptions {
  rootDir: string;
  command: 'start' | 'build' | 'test';
  commandArgs: CommandArgs;
}

interface AnalyzeOptions {
  parallel?: number;
  analyzeRelativeImport?: boolean;
  alias?: Record<string, string>;
}

// Express types for mock functionality
interface Request extends express.Request {}
interface Response extends express.Response {}

Type Definitions