@rimori/client 1.1.10 → 1.3.0

package/dist/cli/scripts/init/file-operations.js

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Configuration mapping source files to destination files.
+ * Key: Source path relative to __dirname
+ * Value: Destination path relative to current working directory
+ */
+const FILE_COPY_MAP = {
+    '../../../../example/rimori.config.ts': './rimori/rimori.config.ts',
+    '../../../../README.md': './rimori/readme.md',
+    '../../../../example/docs/overview.md': './public/docs/overview.md',
+    '../../../../example/docs/devdocs.md': './public/docs/devdocs.md',
+    '../../../../example/docs/userdocs.md': './public/docs/userdocs.md',
+    '../../../../example/worker/worker.ts': './worker/worker.ts',
+    '../../../../example/worker/vite.config.ts': './worker/vite.config.ts',
+};
+/**
+ * Copies necessary files and creates directories for the plugin setup.
+ */
+export function copyPluginFiles() {
+    console.log('Copying plugin files...');
+    for (const [srcRelativePath, destRelativePath] of Object.entries(FILE_COPY_MAP)) {
+        const srcPath = path.resolve(__dirname, srcRelativePath);
+        const destPath = path.resolve(destRelativePath);
+        const destDir = path.dirname(destPath);
+        // Check if source file exists
+        if (!fs.existsSync(srcPath)) {
+            console.log(`Warning: Source file not found: ${srcPath}`);
+            continue;
+        }
+        // Create destination directory if it doesn't exist
+        if (!fs.existsSync(destDir)) {
+            console.log(`Creating directory: ${destDir}`);
+            fs.mkdirSync(destDir, { recursive: true });
+        }
+        // Only copy if destination file doesn't exist
+        if (!fs.existsSync(destPath)) {
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`Copied: ${srcRelativePath} -> ${destRelativePath}`);
+        }
+        else {
+            console.log(`File already exists, skipping: ${destRelativePath}`);
+        }
+    }
+    console.log('Plugin file copying completed.');
+}

package/dist/cli/scripts/init/html-cleaner.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Processes HTML files to remove unwanted meta tags.
+ */
+export declare function cleanHtmlMetaTags(): void;

package/dist/cli/scripts/init/html-cleaner.js

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Removes all meta tags from HTML content except viewport and charset.
+ * @param htmlContent - The HTML content to process.
+ * @returns The processed HTML content with unwanted meta tags removed.
+ */
+function removeUnwantedMetaTags(htmlContent) {
+    // Remove all meta tags except those with name="viewport" or charset attribute
+    let cleanedContent = htmlContent.replace(/<meta\s+(?![^>]*(?:name\s*=\s*["']viewport["']|charset\s*=))[^>]*>/gi, '');
+    // Remove empty lines left behind
+    cleanedContent = cleanedContent.replace(/^\s*[\r\n]/gm, '');
+    return cleanedContent;
+}
+/**
+ * Processes HTML files to remove unwanted meta tags.
+ */
+export function cleanHtmlMetaTags() {
+    const filePath = path.resolve('./index.html');
+    if (!filePath.endsWith('.html')) {
+        return;
+    }
+    if (!fs.existsSync(filePath)) {
+        console.log(`Warning: HTML file not found: ${filePath}`);
+        return;
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const cleanedContent = removeUnwantedMetaTags(content);
+        if (content !== cleanedContent) {
+            fs.writeFileSync(filePath, cleanedContent, 'utf8');
+            console.log(`Cleaned meta tags in: ${filePath}`);
+        }
+    }
+    catch (error) {
+        console.error(`Error processing HTML file ${filePath}:`, error);
+    }
+}

package/dist/cli/scripts/init/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/cli/scripts/init/main.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as fs from 'fs';
+import * as path from 'path';
+import { askForCredentials, askForPort, authenticateWithSupabase, registerDeveloper, } from './dev-registration.js';
+import { setupEnvFile, updateGitignore } from './env-setup.js';
+import { copyPluginFiles } from './file-operations.js';
+import { cleanHtmlMetaTags } from './html-cleaner.js';
+import { updatePackageJson } from './package-setup.js';
+import { transformAppRouter } from './router-transformer.js';
+import { updateTailwindConfig } from './tailwind-config.js';
+import { updateViteConfigBase } from './vite-config.js';
+import 'dotenv/config';
+/**
+ * Main function that handles the complete plugin setup flow.
+ */
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Check for --upgrade flag
+            const isUpgrade = process.argv.includes('--upgrade');
+            if (isUpgrade) {
+                console.log('🔄 Starting Rimori Plugin Upgrade...');
+            }
+            else {
+                console.log('🎯 Starting Rimori Plugin Setup...');
+            }
+            console.log('');
+            // Check if plugin is already initialized (skip for upgrade mode)
+            if (!isUpgrade) {
+                const packageJsonPath = path.resolve('./package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    try {
+                        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                        if (packageJson.r_id) {
+                            console.log('❌ Plugin is already initialized!');
+                            console.log(`Plugin ID: ${packageJson.r_id}`);
+                            console.log('');
+                            console.log('If you want to reinitialize the plugin, please remove the "r_id" field from package.json first.');
+                            console.log('Or use the --upgrade flag to upgrade the plugin configuration without changing the plugin ID.');
+                            process.exit(0);
+                        }
+                    }
+                    catch (error) {
+                        console.warn('Warning: Could not read package.json, continuing with setup...');
+                    }
+                }
+            }
+            let pluginId = '';
+            if (isUpgrade) {
+                // For upgrade mode, only ask for port and setup plugin
+                console.log('🔄 Upgrade mode: Skipping authentication and plugin registration...');
+                console.log('');
+                // Get plugin ID from existing package.json
+                try {
+                    const packageJsonPath = path.resolve('./package.json');
+                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                    pluginId = packageJson.r_id || '';
+                }
+                catch (error) {
+                    console.warn('Warning: Could not read plugin ID from package.json');
+                }
+                // Ask for development port
+                const port = yield askForPort();
+                console.log('');
+                // Update package.json in upgrade mode
+                updatePackageJson({
+                    port,
+                    isUpgrade: true,
+                });
+                // Copy files
+                copyPluginFiles();
+                // Update gitignore
+                updateGitignore();
+            }
+            else {
+                // Step 1: Get user credentials
+                const credentials = yield askForCredentials();
+                console.log('');
+                // Step 2: Authenticate with Supabase
+                const jwtToken = yield authenticateWithSupabase(credentials);
+                console.log('');
+                // Step 3: Ask for development port
+                const port = yield askForPort();
+                console.log('');
+                // Step 4: Register developer and get plugin credentials
+                const { plugin_id, access_token } = yield registerDeveloper(jwtToken, port);
+                pluginId = plugin_id;
+                console.log('');
+                // Step 5: Update package.json
+                updatePackageJson({
+                    pluginId: plugin_id,
+                    port,
+                    isUpgrade: false,
+                });
+                // Step 6: Setup environment file
+                setupEnvFile(access_token);
+                // Step 7: Copy necessary files
+                copyPluginFiles();
+                // Step 8: Update gitignore
+                updateGitignore();
+            }
+            // Setup vite config base
+            try {
+                console.log('Updating vite config base...');
+                updateViteConfigBase();
+                console.log('✅ Vite config base updated');
+            }
+            catch (error) {
+                console.warn(`Warning: Could not update vite.config.ts base property: ${error instanceof Error ? error.message : error}`);
+            }
+            // Clean meta tags from index.html after vite adaptation
+            cleanHtmlMetaTags();
+            console.log('✅ Meta tags cleaned from index.html');
+            // Update Tailwind CSS configuration
+            updateTailwindConfig();
+            // Transform App.tsx to use PluginProvider with HashRouter
+            if (pluginId) {
+                try {
+                    transformAppRouter(pluginId);
+                }
+                catch (error) {
+                    console.warn(`Warning: Could not transform App.tsx router: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+            else {
+                console.warn('Warning: Plugin ID not available, skipping router transformation');
+            }
+            console.log('');
+            console.log('✅ Plugin ' + (isUpgrade ? 'upgrade' : 'setup') + ' completed successfully!');
+            console.log('');
+            console.log('Next steps:');
+            console.log('1. Check out ./rimori/readme.md for more information about how to make the most out of the plugin.');
+            console.log('2. Adapt the ./rimori/rimori.config.ts file to your needs.');
+            console.log('3. Under ./public/docs/ you can find the documentation for an example flashcard plugin to get started easier.');
+            console.log('4. Start development with: yarn dev');
+            console.log('');
+            console.log(`The plugin should now be accessible at: http://localhost:${3000}`);
+            console.log('');
+            console.log('If you want to release the plugin, simply run: "yarn release:<alpha|beta|stable>" (details are available in ./rimori/readme.md)');
+        }
+        catch (error) {
+            console.error(`❌ Error: ${error instanceof Error ? error.message : error}`);
+            console.error('');
+            console.error('Make sure that:');
+            console.error('1. Your Supabase credentials are correct');
+            console.error('2. You have internet connection for authentication');
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/cli/scripts/init/package-setup.d.ts

@@ -0,0 +1,32 @@
+export interface PackageJson {
+    name?: string;
+    r_id?: string;
+    scripts: {
+        dev?: string;
+        [key: string]: string | undefined;
+    };
+    dependencies?: {
+        [key: string]: string;
+    };
+    [key: string]: any;
+}
+export interface PackageSetupParams {
+    pluginId?: string;
+    port?: number;
+    isUpgrade?: boolean;
+}
+/**
+ * Gets the current version of @rimori/client from its package.json.
+ * @returns The current version string with caret prefix.
+ * @throws {Error} if rimori-client package.json cannot be read.
+ */
+export declare function getRimoriClientVersion(): string;
+/**
+ * Updates the plugin's package.json with necessary configuration.
+ * @param param
+ * @param param.pluginId - The unique plugin identifier (optional for upgrade mode).
+ * @param param.port - The development port for the plugin (optional).
+ * @param param.isUpgrade - Whether this is an upgrade operation.
+ * @throws {Error} if plugin directory doesn't exist or package.json is missing.
+ */
+export declare function updatePackageJson({ pluginId, port, isUpgrade, }: PackageSetupParams): void;

package/dist/cli/scripts/init/package-setup.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Gets the current version of @rimori/client from its package.json.
+ * @returns The current version string with caret prefix.
+ * @throws {Error} if rimori-client package.json cannot be read.
+ */
+export function getRimoriClientVersion() {
+    try {
+        // Get the path to rimori-client package.json relative to this script
+        // From dist/cli/scripts/init/ we need to go up 4 levels to reach the root
+        const rimoriClientPackageJsonPath = path.resolve(__dirname, '../../../../package.json');
+        const rimoriClientPackageJson = JSON.parse(fs.readFileSync(rimoriClientPackageJsonPath, 'utf8'));
+        return `^${rimoriClientPackageJson.version}`;
+    }
+    catch (error) {
+        throw new Error(`Failed to read rimori-client version: ${error}`);
+    }
+}
+/**
+ * Updates the plugin's package.json with necessary configuration.
+ * @param param
+ * @param param.pluginId - The unique plugin identifier (optional for upgrade mode).
+ * @param param.port - The development port for the plugin (optional).
+ * @param param.isUpgrade - Whether this is an upgrade operation.
+ * @throws {Error} if plugin directory doesn't exist or package.json is missing.
+ */
+export function updatePackageJson({ pluginId, port, isUpgrade = false, }) {
+    // Get the plugin repo name from the current directory
+    const pluginRepoName = path.basename(process.cwd());
+    console.log(`Setting up plugin: ${pluginRepoName}`);
+    if (pluginId) {
+        console.log(`Plugin ID: ${pluginId}`);
+    }
+    if (port) {
+        console.log(`Port: ${port}`);
+    }
+    // Check if package.json exists in plugin directory
+    const packageJsonPath = path.resolve('./package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error(`package.json not found! Are you in the root directory of the plugin?`);
+    }
+    // Read and parse the existing package.json
+    let packageJson;
+    try {
+        packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Failed to read or parse package.json: ${error}`);
+    }
+    console.log('Updating package.json...');
+    console.log('pluginId', pluginId);
+    // Get the current rimori-client version
+    const rimoriClientVersion = getRimoriClientVersion();
+    // Update the package.json object
+    packageJson.name = pluginRepoName;
+    if (pluginId) {
+        packageJson.r_id = pluginId;
+    }
+    packageJson.scripts = Object.assign(Object.assign({}, packageJson.scripts), { "dev": `vite --port ${port || 3000}`, "build": "yarn run check && vite build", "check": "tsc --project tsconfig.app.json --noEmit --pretty", "release:alpha": "yarn build && yarn rimori-release alpha", "release:beta": "yarn build && yarn rimori-release beta", "release:stable": "yarn build && yarn rimori-release stable", "dev:worker": "VITE_MINIFY=false vite build --watch --config worker/vite.config.ts", "build:worker": "vite build --config worker/vite.config.ts" });
+    packageJson.dependencies = Object.assign(Object.assign({}, packageJson.dependencies), { "@rimori/client": rimoriClientVersion });
+    // Write the updated package.json back to file
+    try {
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf8');
+        console.log('✅ Successfully updated package.json');
+    }
+    catch (error) {
+        throw new Error(`Failed to update package.json: ${error}`);
+    }
+}

package/dist/cli/scripts/init/router-transformer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transform App.tsx to use PluginProvider with HashRouter instead of BrowserRouter.
+ * Also converts route components to lazy loading with Suspense.
+ * @param pluginId - The plugin ID to use in PluginProvider
+ */
+export declare function transformAppRouter(pluginId: string): void;

package/dist/cli/scripts/init/router-transformer.js

@@ -0,0 +1,254 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Transform App.tsx to use PluginProvider with HashRouter instead of BrowserRouter.
+ * Also converts route components to lazy loading with Suspense.
+ * @param pluginId - The plugin ID to use in PluginProvider
+ */
+export function transformAppRouter(pluginId) {
+    const appTsxPath = path.resolve('./src/App.tsx');
+    if (!fs.existsSync(appTsxPath)) {
+        console.warn('Warning: App.tsx not found, skipping router transformation');
+        return;
+    }
+    let content = fs.readFileSync(appTsxPath, 'utf8');
+    // Check if PluginProvider is already applied
+    if (content.includes('PluginProvider')) {
+        console.log('✅ PluginProvider already applied, skipping router transformation');
+        return;
+    }
+    // Check if BrowserRouter exists
+    if (!content.includes('BrowserRouter')) {
+        console.log('✅ BrowserRouter not found, skipping router transformation');
+        return;
+    }
+    console.log('🔄 Transforming App.tsx to use PluginProvider with HashRouter...');
+    // Step 1: Detect and extract route components
+    const routeComponents = detectRouteComponents(content);
+    if (routeComponents.length > 0) {
+        console.log(`🔄 Found ${routeComponents.length} route components, converting to lazy loading...`);
+        // Step 2: Transform imports to lazy loading
+        content = transformToLazyImports(content, routeComponents);
+        // Step 3: Add Suspense wrapper around Routes
+        content = addSuspenseWrapper(content);
+    }
+    // Step 4: Transform router imports and JSX (existing functionality)
+    content = transformImports(content);
+    content = transformJSX(content, pluginId);
+    // Write the transformed content back
+    fs.writeFileSync(appTsxPath, content, 'utf8');
+    console.log('✅ App.tsx transformed successfully with lazy loading');
+}
+/**
+ * Detects route components in the JSX by parsing Route elements.
+ * Looks for patterns like: <Route path="/" element={<ComponentName />} />
+ * @param content - The file content to analyze
+ * @returns Array of detected route components with their import information
+ */
+function detectRouteComponents(content) {
+    const routeComponents = [];
+    // Regex to match Route elements with component references
+    // Matches: <Route ... element={<ComponentName .../>} ... />
+    const routeRegex = /<Route[^>]*element=\{\s*<(\w+)[^}]*\}[^>]*\/?>/g;
+    let match;
+    const componentNames = new Set();
+    // Extract all unique component names from routes
+    while ((match = routeRegex.exec(content)) !== null) {
+        const componentName = match[1];
+        componentNames.add(componentName);
+    }
+    // For each component, find its corresponding import statement
+    componentNames.forEach(componentName => {
+        const importInfo = findImportForComponent(content, componentName);
+        if (importInfo) {
+            routeComponents.push({
+                componentName,
+                importStatement: importInfo.importStatement,
+                importPath: importInfo.importPath,
+                isDefaultImport: importInfo.isDefaultImport
+            });
+        }
+    });
+    return routeComponents;
+}
+/**
+ * Finds the import statement for a given component name.
+ * Handles both default imports and named imports.
+ * @param content - The file content to search
+ * @param componentName - The component name to find import for
+ * @returns Import information or null if not found
+ */
+function findImportForComponent(content, componentName) {
+    // Check for default import: import ComponentName from "path"
+    const defaultImportRegex = new RegExp(`import\\s+${componentName}\\s+from\\s+["']([^"']+)["'];?`, 'g');
+    const defaultMatch = defaultImportRegex.exec(content);
+    if (defaultMatch) {
+        return {
+            importStatement: defaultMatch[0],
+            importPath: defaultMatch[1],
+            isDefaultImport: true
+        };
+    }
+    // Check for named import: import { ComponentName } from "path"
+    const namedImportRegex = /import\s*\{\s*([^}]*)\s*\}\s*from\s*["']([^"']+)["'];?/g;
+    let namedMatch;
+    while ((namedMatch = namedImportRegex.exec(content)) !== null) {
+        const imports = namedMatch[1].split(',').map(imp => imp.trim());
+        if (imports.includes(componentName)) {
+            return {
+                importStatement: namedMatch[0],
+                importPath: namedMatch[2],
+                isDefaultImport: false
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Transforms regular component imports to lazy imports.
+ * Converts: import ComponentName from "./path"
+ * To: const ComponentName = lazy(() => import("./path"))
+ * @param content - The file content to transform
+ * @param routeComponents - Array of route components to transform
+ * @returns Transformed content with lazy imports
+ */
+function transformToLazyImports(content, routeComponents) {
+    let transformedContent = content;
+    // Add lazy import if not already present
+    if (!content.includes('lazy')) {
+        transformedContent = addLazyImport(transformedContent);
+    }
+    // Transform each route component import
+    routeComponents.forEach((component, index) => {
+        const { componentName, importStatement, importPath, isDefaultImport } = component;
+        // Create lazy import statement
+        const lazyImport = isDefaultImport
+            ? `const ${componentName} = lazy(() => import("${importPath}"));`
+            : `const ${componentName} = lazy(() => import("${importPath}").then(module => ({ default: module.${componentName} })));`;
+        // Replace the original import with lazy import
+        transformedContent = transformedContent.replace(importStatement, (index === 0 ? '\n' : '') + lazyImport);
+    });
+    return transformedContent;
+}
+/**
+ * Adds lazy import from React if not already present.
+ * @param content - The file content to modify
+ * @returns Content with lazy import added
+ */
+function addLazyImport(content) {
+    // Check if React import exists and update it
+    const reactImportRegex = /import\s+(?:\*\s+as\s+)?React(?:\s*,\s*\{\s*([^}]*)\s*\})?\s+from\s+["']react["'];?/;
+    const reactImportMatch = content.match(reactImportRegex);
+    if (reactImportMatch) {
+        // React import exists, add lazy to it
+        const existingImports = reactImportMatch[1] || '';
+        const importList = existingImports.split(',').map(imp => imp.trim()).filter(Boolean);
+        if (!importList.includes('lazy')) {
+            importList.push('lazy');
+        }
+        if (!importList.includes('Suspense')) {
+            importList.push('Suspense');
+        }
+        const newImport = importList.length > 0
+            ? `import React, { ${importList.join(', ')} } from "react";`
+            : `import React from "react";`;
+        return content.replace(reactImportMatch[0], newImport);
+    }
+    else {
+        // No React import found, add it
+        const firstImportMatch = content.match(/^import.*$/m);
+        if (firstImportMatch) {
+            return content.replace(firstImportMatch[0], `import React, { lazy, Suspense } from "react";\n${firstImportMatch[0]}`);
+        }
+        else {
+            // No imports found, add at the beginning
+            return `import React, { lazy, Suspense } from "react";\n${content}`;
+        }
+    }
+}
+/**
+ * Wraps the Routes component with Suspense for lazy loading fallback.
+ * Converts: <Routes>...</Routes>
+ * To: <Suspense fallback={<div>Loading...</div>}><Routes>...</Routes></Suspense>
+ * @param content - The file content to modify
+ * @returns Content with Suspense wrapper added
+ */
+function addSuspenseWrapper(content) {
+    // Check if Suspense is already wrapping Routes
+    if (content.includes('<Suspense') && content.match(/<Suspense[^>]*>[\s\S]*<Routes/)) {
+        console.log('✅ Suspense wrapper already present');
+        return content;
+    }
+    // Find Routes component and wrap with Suspense
+    // Handle both self-closing and regular Routes tags
+    const routesRegex = /(<Routes(?:[^>]*)>)([\s\S]*?)(<\/Routes>)/;
+    const selfClosingRoutesRegex = /(<Routes[^>]*\/>)/;
+    const routesMatch = content.match(routesRegex);
+    const selfClosingMatch = content.match(selfClosingRoutesRegex);
+    if (routesMatch) {
+        // Regular Routes with children
+        const [fullMatch, openTag, children, closeTag] = routesMatch;
+        const suspenseWrapper = `<Suspense fallback={<div className="flex items-center justify-center min-h-screen"><div className="text-lg">Loading...</div></div>}>\n        ${openTag}${children}${closeTag}\n      </Suspense>`;
+        return content.replace(fullMatch, suspenseWrapper);
+    }
+    else if (selfClosingMatch) {
+        // Self-closing Routes
+        const suspenseWrapper = `<Suspense fallback={<div className="flex items-center justify-center min-h-screen"><div className="text-lg">Loading...</div></div>}>\n        ${selfClosingMatch[1]}\n      </Suspense>`;
+        return content.replace(selfClosingMatch[1], suspenseWrapper);
+    }
+    console.log('✅ Routes component not found, skipping Suspense wrapper');
+    return content;
+}
+/**
+ * Transform the import statements to include PluginProvider and change BrowserRouter to HashRouter.
+ * This is the original functionality for router transformation.
+ * @param content - The file content to transform
+ * @returns Transformed content with updated imports
+ */
+function transformImports(content) {
+    // Add PluginProvider import
+    if (!content.includes('import') || !content.includes('@rimori/client')) {
+        // Add new import line for PluginProvider
+        const importMatch = content.match(/^(import.*from\s+["']react["'];?\s*\n)/m);
+        if (importMatch) {
+            content = content.replace(importMatch[0], `${importMatch[0]}import { PluginProvider } from "@rimori/client";\n`);
+        }
+        else {
+            // If no React import found, add at the beginning
+            content = `import { PluginProvider } from "@rimori/client";\n${content}`;
+        }
+    }
+    else {
+        // Update existing @rimori/client import to include PluginProvider
+        content = content.replace(/import\s*{\s*([^}]*)\s*}\s*from\s*["']@rimori\/client["'];?/, (match, imports) => {
+            const importList = imports.split(',').map((imp) => imp.trim()).filter(Boolean);
+            if (!importList.includes('PluginProvider')) {
+                importList.push('PluginProvider');
+            }
+            return `import { ${importList.join(', ')} } from "@rimori/client";`;
+        });
+    }
+    // Transform react-router-dom import: replace BrowserRouter with HashRouter
+    content = content.replace(/import\s*{\s*([^}]*)\s*}\s*from\s*["']react-router-dom["'];?/, (match, imports) => {
+        const importList = imports.split(',').map((imp) => imp.trim()).filter(Boolean);
+        const updatedImports = importList.map((imp) => imp === 'BrowserRouter' ? 'HashRouter' : imp);
+        return `import { ${updatedImports.join(', ')} } from "react-router-dom";`;
+    });
+    return content;
+}
+/**
+ * Transform the JSX to wrap with PluginProvider and change BrowserRouter to HashRouter.
+ * This is the original functionality for router transformation.
+ * @param content - The file content to transform
+ * @param pluginId - The plugin ID to use in PluginProvider
+ * @returns Transformed content with updated JSX
+ */
+function transformJSX(content, pluginId) {
+    // Replace opening BrowserRouter tag
+    content = content.replace(/<BrowserRouter(\s[^>]*)?>/, `<PluginProvider pluginId="${pluginId}">
+      <HashRouter future={{ v7_startTransition: true, v7_relativeSplatPath: true }}>`);
+    // Replace closing BrowserRouter tag
+    content = content.replace(/<\/BrowserRouter>/, `</HashRouter>
+    </PluginProvider>`);
+    return content;
+}

package/dist/cli/scripts/init/tailwind-config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Updates the tailwind.config.ts file to set darkMode to "class" and add the Rimori client package to content.
+ */
+export declare function updateTailwindConfig(): void;