@stachelock/ui 0.1.9 → 0.2.1

package/scripts/generateRecursiveIndex.cjs

@@ -0,0 +1,255 @@
+/* eslint-env node */
+/* eslint-disable no-undef */
+const fs = require('fs');
+const path = require('path');
+
+// Function to convert to camelCase
+function toCamelCase(str) {
+  return str.replace(/[_-](.)/g, (_, group1) => group1.toUpperCase());
+}
+
+// Function to convert to PascalCase
+function toPascalCase(str) {
+  const camelCase = toCamelCase(str);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+}
+
+// Function to generate export name for components
+function generateComponentExportName(fileName, directoryName) {
+  const cleanFileName = fileName.replace(/^Ui/, '').replace(/^Sl/, '');
+  const pascalFileName = toPascalCase(cleanFileName);
+  
+  // For base components, just return the clean name
+  if (directoryName === 'components') {
+    return pascalFileName;
+  }
+  
+  // For subdirectories, use a more intuitive naming
+  if (['layouts', 'inputs', 'calendars', 'forms'].includes(directoryName)) {
+    // Remove the 's' from the end and capitalize
+    const singularDirName = directoryName.slice(0, -1);
+    const pascalDirName = toPascalCase(singularDirName);
+    
+    // Special cases for better naming
+    if (singularDirName === 'layout') {
+      return pascalFileName; // Just use the component name for layouts
+    }
+    if (singularDirName === 'input') {
+      return pascalFileName; // Just use the component name for inputs
+    }
+    if (singularDirName === 'calendar') {
+      return pascalFileName; // Just use the component name for calendars
+    }
+    if (singularDirName === 'form') {
+      // Handle naming conflicts with types
+      if (fileName === 'DynamicFormField') {
+        return 'FormField'; // Avoid conflict with type
+      }
+      return pascalFileName; // Just use the component name for forms
+    }
+    
+    return `${pascalDirName}${pascalFileName}`;
+  }
+  
+  return pascalFileName;
+}
+
+// Function to generate index file for a directory
+function generateIndexFile(directoryPath, baseDirectoryPath = directoryPath) {
+  const files = fs.readdirSync(directoryPath, { withFileTypes: true });
+  let exportStatements = [];
+  let hasExports = false;
+
+  for (const file of files) {
+    if (file.isDirectory()) {
+      // Skip certain directories
+      if (['tests', 'test', '__tests__', 'node_modules', '.git'].includes(file.name.toLowerCase())) {
+        continue;
+      }
+
+      // Recursively handle subdirectories
+      const subDirectoryPath = path.join(directoryPath, file.name);
+      if (generateIndexFile(subDirectoryPath, baseDirectoryPath)) {
+        exportStatements.push(`export * from './${file.name}';`);
+        hasExports = true;
+      }
+    } else if (file.name.endsWith('.vue') && file.name !== 'index.vue') {
+      const fileName = file.name.replace('.vue', '');
+      const directoryName = path.basename(directoryPath);
+      const exportName = generateComponentExportName(fileName, directoryName);
+      
+      exportStatements.push(`export { default as ${exportName} } from './${fileName}.vue';`);
+      hasExports = true;
+    } else if (file.name.endsWith('.ts') && file.name !== 'index.ts' && !file.name.endsWith('.d.ts')) {
+      const fileName = file.name.replace('.ts', '');
+      // For types directory, export all type files
+      if (path.basename(baseDirectoryPath) === 'types') {
+        exportStatements.push(`export * from './${fileName}';`);
+      } else {
+        exportStatements.push(`export * from './${fileName}';`);
+      }
+      hasExports = true;
+    }
+  }
+
+  if (hasExports) {
+    const indexPath = path.join(directoryPath, 'index.ts');
+    const content = exportStatements.join('\n') + '\n';
+    
+    // Only write if content is different to avoid unnecessary file changes
+    if (!fs.existsSync(indexPath) || fs.readFileSync(indexPath, 'utf8') !== content) {
+      fs.writeFileSync(indexPath, content);
+      console.log(`✅ Generated index.ts for ${path.relative(baseDirectoryPath, directoryPath)}`);
+    }
+    return true;
+  }
+  
+  return false;
+}
+
+// Function to generate main index file
+function generateMainIndexFile(srcDirectoryPath) {
+  const mainIndexPath = path.join(srcDirectoryPath, 'index.ts');
+  
+  // Generate new content - clean, non-prefixed exports only
+  const exportStatements = [
+    "// Types",
+    "export * from './types';",
+    "",
+    "// Utils", 
+    "export * from './utils/id';",
+    "export * from './utils/component-registry';",
+    "",
+    "// Configuration System",
+    "export * from './config/design-tokens';",
+    "export * from './config/css-variables';",
+    "",
+    "// Base UI Components",
+    "export * from './components';",
+    "",
+    "// Layout Components",
+    "export * from './components/layouts';",
+    "",
+    "// Input Components", 
+    "export * from './components/inputs';",
+    "",
+    "// Calendar Components",
+    "export * from './components/calendars';",
+    "",
+    "// Form Components",
+    "export * from './components/forms';",
+    "",
+    "// Plugin interface and Vue plugin",
+    "export { StachelockUI, type StachelockUIOptions } from './plugin';",
+    "export { StachelockUI as default } from './plugin';"
+  ];
+  
+  const newContent = exportStatements.join('\n') + '\n';
+  
+  // Always write to ensure consistency
+  fs.writeFileSync(mainIndexPath, newContent);
+  console.log(`✅ Generated main index.ts`);
+}
+
+// Function to generate plugin file
+function generatePluginFile(srcDirectoryPath) {
+  const pluginPath = path.join(srcDirectoryPath, 'plugin.ts');
+  
+  const pluginContent = `import type { App } from 'vue';
+import * as components from './components';
+import * as layouts from './components/layouts';
+import * as inputs from './components/inputs';
+import * as calendars from './components/calendars';
+import * as forms from './components/forms';
+
+// Combine all components
+const allComponents = {
+  ...components,
+  ...layouts,
+  ...inputs,
+  ...calendars,
+  ...forms,
+};
+
+// Plugin interface
+export interface StachelockUIOptions {
+  /**
+   * Component name prefix (default: 'Sl')
+   */
+  prefix?: string;
+  /**
+   * Array of component names to install globally
+   */
+  components?: string[];
+  /**
+   * Whether to install all components globally
+   */
+  installAll?: boolean;
+}
+
+// Vue plugin
+export const StachelockUI = {
+  install(app: App, options: StachelockUIOptions = {}) {
+    const { prefix = 'Sl', installAll = false, components: selectedComponents } = options;
+
+    // Register components
+    Object.entries(allComponents).forEach(([name, component]) => {
+      const shouldInstall = installAll || 
+        (selectedComponents && selectedComponents.includes(name)) ||
+        (!selectedComponents && !installAll);
+
+      if (shouldInstall) {
+        // Register non-prefixed
+        app.component(name, component);
+        // Also register prefixed alias for back-compat
+        const prefixedName = name.startsWith(prefix) ? name : \`\${prefix}\${name}\`;
+        app.component(prefixedName, component);
+      }
+    });
+  }
+};
+
+export default StachelockUI;
+`;
+
+  // Only write if content is different
+  if (!fs.existsSync(pluginPath) || fs.readFileSync(pluginPath, 'utf8') !== pluginContent) {
+    fs.writeFileSync(pluginPath, pluginContent);
+    console.log(`✅ Generated plugin.ts`);
+  }
+}
+
+// Main execution
+function main() {
+  console.log('🚀 Generating recursive index files for stachelock-ui...\n');
+  
+  const srcDirectoryPath = path.join(__dirname, '../src');
+  
+  if (!fs.existsSync(srcDirectoryPath)) {
+    console.error('❌ src directory not found!');
+    process.exit(1);
+  }
+  
+  try {
+    // Generate index files for all subdirectories
+    generateIndexFile(srcDirectoryPath);
+    
+    // Generate main index file
+    generateMainIndexFile(srcDirectoryPath);
+    
+    // Don't generate plugin file - we have a custom one
+    // generatePluginFile(srcDirectoryPath);
+    
+    console.log('\n✨ All index files generated successfully!');
+  } catch (error) {
+    console.error('❌ Error generating index files:', error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { generateIndexFile, generateMainIndexFile, generatePluginFile };