kimu-core 0.4.1

package/scripts/install-module.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * KIMU Module Installer
+ * 
+ * Installs a module from modules-repository to modules folder
+ * Usage: npm run install:module <module-name>
+ * Example: npm run install:module router
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ROOT_DIR = path.resolve(__dirname, '..');
+const REPOSITORY_DIR = path.join(ROOT_DIR, 'src', 'modules-repository');
+const MODULES_DIR = path.join(ROOT_DIR, 'src', 'modules');
+const MANIFEST_PATH = path.join(MODULES_DIR, 'modules-manifest.json');
+
+/**
+ * Copy directory recursively
+ */
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Read module manifest from repository
+ */
+function readModuleManifest(moduleName) {
+  const manifestPath = path.join(REPOSITORY_DIR, moduleName, 'manifest.json');
+  
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Module manifest not found: ${manifestPath}`);
+  }
+
+  return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+}
+
+/**
+ * Read installed modules manifest
+ */
+function readInstalledManifest() {
+  if (!fs.existsSync(MANIFEST_PATH)) {
+    return {
+      installedModules: [],
+      availableModules: [],
+      lastUpdate: new Date().toISOString()
+    };
+  }
+
+  return JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+}
+
+/**
+ * Write installed modules manifest
+ */
+function writeInstalledManifest(manifest) {
+  fs.writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2), 'utf8');
+}
+
+/**
+ * Install module
+ */
+function installModule(moduleName) {
+  console.log(`\n📦 Installing module: ${moduleName}...`);
+
+  // Check if module exists in repository
+  const moduleRepoPath = path.join(REPOSITORY_DIR, moduleName);
+  if (!fs.existsSync(moduleRepoPath)) {
+    console.error(`❌ Error: Module '${moduleName}' not found in repository.`);
+    console.log(`   Available modules in repository:`);
+    const availableModules = fs.readdirSync(REPOSITORY_DIR, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+    availableModules.forEach(mod => console.log(`   - ${mod}`));
+    process.exit(1);
+  }
+
+  // Read module manifest
+  const moduleManifest = readModuleManifest(moduleName);
+  console.log(`   Version: ${moduleManifest.version}`);
+  console.log(`   Description: ${moduleManifest.description}`);
+
+  // Check if already installed
+  const installedManifest = readInstalledManifest();
+  const alreadyInstalled = installedManifest.installedModules.find(
+    mod => mod.name === moduleName
+  );
+
+  if (alreadyInstalled) {
+    console.log(`⚠️  Module '${moduleName}' is already installed (v${alreadyInstalled.version}).`);
+    console.log(`   To reinstall, first remove it with: npm run remove:module ${moduleName}`);
+    process.exit(0);
+  }
+
+  // Copy module from repository to modules
+  const moduleDestPath = path.join(MODULES_DIR, moduleName);
+  console.log(`   Copying from: ${moduleRepoPath}`);
+  console.log(`   Copying to: ${moduleDestPath}`);
+
+  try {
+    copyDirectory(moduleRepoPath, moduleDestPath);
+    console.log(`   ✓ Files copied successfully`);
+  } catch (error) {
+    console.error(`❌ Error copying module files:`, error.message);
+    process.exit(1);
+  }
+
+  // Update installed manifest
+  installedManifest.installedModules.push({
+    name: moduleName,
+    version: moduleManifest.version,
+    path: moduleName,
+    installedAt: new Date().toISOString()
+  });
+  installedManifest.lastUpdate = new Date().toISOString();
+
+  writeInstalledManifest(installedManifest);
+  console.log(`   ✓ Manifest updated`);
+
+  console.log(`\n✅ Module '${moduleName}' installed successfully!`);
+  console.log(`   You can now import it in your code:`);
+  console.log(`   import ${moduleManifest.name}Module from './modules/${moduleName}/module';`);
+  console.log(`\n   Run 'npm run build' to include it in the production bundle.\n`);
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  const moduleName = process.argv[2];
+
+  if (!moduleName) {
+    console.error('❌ Error: Module name is required.');
+    console.log('\nUsage: npm run install:module <module-name>');
+    console.log('Example: npm run install:module router\n');
+    process.exit(1);
+  }
+
+  installModule(moduleName);
+}
+
+main();

package/scripts/list-modules.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * KIMU Module Lister
+ * 
+ * Lists available and installed modules
+ * Usage: npm run list:modules
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ROOT_DIR = path.resolve(__dirname, '..');
+const REPOSITORY_DIR = path.join(ROOT_DIR, 'src', 'modules-repository');
+const MODULES_DIR = path.join(ROOT_DIR, 'src', 'modules');
+const MANIFEST_PATH = path.join(MODULES_DIR, 'modules-manifest.json');
+
+/**
+ * Read module manifest from repository
+ */
+function readModuleManifest(moduleName) {
+  const manifestPath = path.join(REPOSITORY_DIR, moduleName, 'manifest.json');
+  
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+
+  return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+}
+
+/**
+ * Read installed modules manifest
+ */
+function readInstalledManifest() {
+  if (!fs.existsSync(MANIFEST_PATH)) {
+    return {
+      installedModules: [],
+      availableModules: [],
+      lastUpdate: new Date().toISOString()
+    };
+  }
+
+  return JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+}
+
+/**
+ * List modules
+ */
+function listModules() {
+  console.log(`\n📦 KIMU Modules Status\n`);
+
+  // Read installed manifest
+  const installedManifest = readInstalledManifest();
+  const installedNames = installedManifest.installedModules.map(mod => mod.name);
+
+  // List installed modules
+  console.log(`✅ Installed Modules (${installedManifest.installedModules.length}):`);
+  if (installedManifest.installedModules.length === 0) {
+    console.log(`   (none)`);
+  } else {
+    installedManifest.installedModules.forEach(mod => {
+      console.log(`   • ${mod.name} (v${mod.version}) - installed ${new Date(mod.installedAt).toLocaleDateString()}`);
+    });
+  }
+
+  console.log();
+
+  // List available modules in repository
+  const availableModules = fs.readdirSync(REPOSITORY_DIR, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name)
+    .filter(name => !installedNames.includes(name));
+
+  console.log(`📚 Available Modules in Repository (${availableModules.length}):`);
+  if (availableModules.length === 0) {
+    console.log(`   (all modules are installed)`);
+  } else {
+    availableModules.forEach(moduleName => {
+      const manifest = readModuleManifest(moduleName);
+      if (manifest) {
+        console.log(`   • ${moduleName} (v${manifest.version}) - ${manifest.description}`);
+      } else {
+        console.log(`   • ${moduleName} (no manifest)`);
+      }
+    });
+  }
+
+  console.log();
+
+  // Show commands
+  console.log(`Commands:`);
+  console.log(`   Install:  npm run install:module <module-name>`);
+  console.log(`   Remove:   npm run remove:module <module-name>`);
+  console.log(`   List:     npm run list:modules`);
+  console.log();
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  listModules();
+}
+
+main();

package/scripts/minify-css-assets.js

@@ -0,0 +1,82 @@
+/**
+ * This script minifies CSS files in the dist/assets folder after build.
+ * It removes comments, whitespace, and optimizes the CSS for production.
+ * 
+ * Key functionalities:
+ * - Reads all CSS files from dist/assets
+ * - Minifies each CSS file by removing comments and excess whitespace
+ * - Preserves the original file structure
+ * - Logs the size reduction for each file
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get the directory name of the current script file
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Resolve the path to the dist/assets directory
+const assetsPath = path.resolve(__dirname, '../dist/assets');
+
+/**
+ * Simple CSS minification function
+ * - Removes comments
+ * - Removes excess whitespace
+ * - Compresses color codes
+ */
+function minifyCSS(css) {
+  return css
+    // Remove comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Remove whitespace around selectors and declarations
+    .replace(/\s*([{}:;,])\s*/g, '$1')
+    // Remove leading/trailing whitespace
+    .trim()
+    // Remove empty rules
+    .replace(/[^}]+\{\}/g, '')
+    // Compress color codes (#ffffff -> #fff)
+    .replace(/#([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3/gi, '#$1$2$3');
+}
+
+/**
+ * Process all CSS files in the assets directory
+ */
+function minifyAssetsCSS() {
+  if (!fs.existsSync(assetsPath)) {
+    console.log('[KIMU] ⚠️ Assets directory not found, skipping CSS minification');
+    return;
+  }
+
+  const files = fs.readdirSync(assetsPath);
+  const cssFiles = files.filter(file => file.endsWith('.css'));
+
+  if (cssFiles.length === 0) {
+    console.log('[KIMU] ℹ️ No CSS files found in assets directory');
+    return;
+  }
+
+  let totalSaved = 0;
+
+  cssFiles.forEach(file => {
+    const filePath = path.join(assetsPath, file);
+    const originalContent = fs.readFileSync(filePath, 'utf-8');
+    const originalSize = Buffer.byteLength(originalContent, 'utf-8');
+    
+    const minifiedContent = minifyCSS(originalContent);
+    const minifiedSize = Buffer.byteLength(minifiedContent, 'utf-8');
+    
+    fs.writeFileSync(filePath, minifiedContent, 'utf-8');
+    
+    const saved = originalSize - minifiedSize;
+    totalSaved += saved;
+    
+    const reduction = ((saved / originalSize) * 100).toFixed(1);
+    console.log(`[KIMU] ✅ Minified ${file}: ${(originalSize/1024).toFixed(2)}KB → ${(minifiedSize/1024).toFixed(2)}KB (-${reduction}%)`);
+  });
+
+  console.log(`[KIMU] 🎉 Total CSS size reduction: ${(totalSaved/1024).toFixed(2)}KB`);
+}
+
+// Run the minification
+minifyAssetsCSS();

package/scripts/remove-module.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * KIMU Module Remover
+ * 
+ * Removes an installed module from modules folder
+ * Usage: npm run remove:module <module-name>
+ * Example: npm run remove:module router
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ROOT_DIR = path.resolve(__dirname, '..');
+const MODULES_DIR = path.join(ROOT_DIR, 'src', 'modules');
+const MANIFEST_PATH = path.join(MODULES_DIR, 'modules-manifest.json');
+
+/**
+ * Remove directory recursively
+ */
+function removeDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Read installed modules manifest
+ */
+function readInstalledManifest() {
+  if (!fs.existsSync(MANIFEST_PATH)) {
+    return {
+      installedModules: [],
+      availableModules: [],
+      lastUpdate: new Date().toISOString()
+    };
+  }
+
+  return JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+}
+
+/**
+ * Write installed modules manifest
+ */
+function writeInstalledManifest(manifest) {
+  fs.writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2), 'utf8');
+}
+
+/**
+ * Remove module
+ */
+function removeModule(moduleName) {
+  console.log(`\n🗑️  Removing module: ${moduleName}...`);
+
+  // Read installed manifest
+  const installedManifest = readInstalledManifest();
+  const moduleIndex = installedManifest.installedModules.findIndex(
+    mod => mod.name === moduleName
+  );
+
+  if (moduleIndex === -1) {
+    console.error(`❌ Error: Module '${moduleName}' is not installed.`);
+    console.log(`\n   Currently installed modules:`);
+    if (installedManifest.installedModules.length === 0) {
+      console.log(`   (none)`);
+    } else {
+      installedManifest.installedModules.forEach(mod => {
+        console.log(`   - ${mod.name} (v${mod.version})`);
+      });
+    }
+    process.exit(1);
+  }
+
+  const moduleInfo = installedManifest.installedModules[moduleIndex];
+  console.log(`   Version: ${moduleInfo.version}`);
+  console.log(`   Installed at: ${moduleInfo.installedAt}`);
+
+  // Remove module directory
+  const modulePath = path.join(MODULES_DIR, moduleName);
+  console.log(`   Removing: ${modulePath}`);
+
+  try {
+    removeDirectory(modulePath);
+    console.log(`   ✓ Files removed successfully`);
+  } catch (error) {
+    console.error(`❌ Error removing module files:`, error.message);
+    process.exit(1);
+  }
+
+  // Update installed manifest
+  installedManifest.installedModules.splice(moduleIndex, 1);
+  installedManifest.lastUpdate = new Date().toISOString();
+
+  writeInstalledManifest(installedManifest);
+  console.log(`   ✓ Manifest updated`);
+
+  console.log(`\n✅ Module '${moduleName}' removed successfully!`);
+  console.log(`   The module is still available in modules-repository.`);
+  console.log(`   You can reinstall it with: npm run install:module ${moduleName}\n`);
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  const moduleName = process.argv[2];
+
+  if (!moduleName) {
+    console.error('❌ Error: Module name is required.');
+    console.log('\nUsage: npm run remove:module <module-name>');
+    console.log('Example: npm run remove:module router\n');
+    process.exit(1);
+  }
+
+  removeModule(moduleName);
+}
+
+main();

package/scripts/utils/fix-imports.js

@@ -0,0 +1,85 @@
+/**
+ * Utility module for fixing import paths in JavaScript files
+ * by adding .js extensions to relative imports that don't have them.
+ */
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Fix import paths in a JavaScript file
+ * @param {string} filePath - Path to the JavaScript file to fix
+ * @returns {boolean} - True if file was modified, false otherwise
+ */
+export function fixImportsInFile(filePath) {
+  if (!fs.existsSync(filePath) || !filePath.endsWith('.js')) {
+    return false;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  // Replace relative imports without .js extension
+  const fixedContent = content
+    .replace(/from\s*["']([\.\/][^"']*?)["']/g, (match, path) => {
+      if (!path.includes('.js') && !path.includes('.json')) {
+        return match.replace(path, path + '.js');
+      }
+      return match;
+    })
+    .replace(/import\s*\(\s*["']([\.\/][^"']*?)["']\s*\)/g, (match, path) => {
+      if (!path.includes('.js') && !path.includes('.json')) {
+        return match.replace(path, path + '.js');
+      }
+      return match;
+    });
+  
+  if (content !== fixedContent) {
+    fs.writeFileSync(filePath, fixedContent, 'utf8');
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Process all JavaScript files in a directory recursively
+ * @param {string} dir - Directory to process
+ * @returns {number} - Number of files fixed
+ */
+export function fixImportsInDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return 0;
+  }
+  
+  const items = fs.readdirSync(dir, { withFileTypes: true });
+  let fixedCount = 0;
+  
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+    
+    if (item.isDirectory()) {
+      fixedCount += fixImportsInDirectory(fullPath);
+    } else if (item.isFile() && item.name.endsWith('.js')) {
+      if (fixImportsInFile(fullPath)) {
+        fixedCount++;
+      }
+    }
+  }
+  
+  return fixedCount;
+}
+
+/**
+ * Fix imports in multiple files
+ * @param {string[]} filePaths - Array of file paths to fix
+ * @returns {number} - Number of files fixed
+ */
+export function fixImportsInFiles(filePaths) {
+  let fixedCount = 0;
+  
+  for (const filePath of filePaths) {
+    if (fixImportsInFile(filePath)) {
+      fixedCount++;
+    }
+  }
+  
+  return fixedCount;
+}

package/src/assets/index.css

@@ -0,0 +1,43 @@
+/*
+This file can be freely modified by developers.
+Changes made to this page are not subject to the publication requirement of the MPL framework license.
+*/
+
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #f4f1ea;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+}

package/src/assets/kimu-style.css

@@ -0,0 +1,84 @@
+/*
+This file can be freely modified by developers.
+Changes made to this page are not subject to the publication requirement of the MPL framework license.
+*/
+
+/**
+ * KIMU Component Styles
+ * 
+ * This file defines component styles using CSS custom properties (variables).
+ * The variables are defined in two places:
+ * 
+ * 1. style.css - provides DEFAULT values (fallback when theme module is not installed)
+ * 2. /themes/*.css - theme module CSS files that OVERRIDE defaults when a theme is active
+ * 
+ * This approach ensures the app has basic styling even without the theme module.
+ */
+
+/* Base component style - uses theme colors */
+.kimu-component {
+  display: block;
+  color: var(--kimu-text-primary);
+  background-color: transparent;
+  font-family: var(--kimu-font);
+  font-optical-sizing: auto;
+  font-weight: 400;
+  font-style: normal;
+  text-align: center;
+}
+
+.card {
+  width: 100%;
+  height: 100%;
+  padding: 1.5rem;
+  border-radius: var(--kimu-radius);
+  background: var(--kimu-surface);
+  box-shadow: var(--kimu-shadow-lg);
+  border: 1px solid var(--kimu-border);
+  box-sizing: border-box;
+  overflow: auto;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+
+.text-center {
+  text-align: center;
+}
+
+/* Buttons */
+button {
+  /* width: 100%; */
+  font-family: inherit;
+  font-size: 0.8rem;
+  font-weight: 500;
+  text-align: center;
+  text-wrap: auto;
+  text-wrap-mode: nowrap;
+  margin-top: 1rem;
+  padding: 0.5rem 1rem;
+  background-color: var(--kimu-primary);
+  color: var(--kimu-text-on-primary);
+  border: 1px solid var(--kimu-border);
+  border-radius: var(--kimu-radius);
+  box-shadow: var(--kimu-shadow);
+  cursor: pointer;
+  transition: all 0.2s ease-in-out;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.25rem;
+  font-weight: 500;
+}
+
+button:hover {
+  background-color: var(--kimu-primary-dark);
+  transform: translateY(-2px);
+  box-shadow: var(--kimu-shadow-lg);
+}
+
+button:active {
+  transform: scale(0.98);
+  box-shadow: var(--kimu-shadow);
+}