@ornikar/kitt-universal 25.60.0 → 25.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ornikar/kitt-universal",
-  "version": "25.60.0",
+  "version": "25.61.0",
   "license": "MIT",
   "repository": {
     "directory": "@ornikar/kitt-universal",
@@ -71,6 +71,9 @@
     "./translations/es-ES.json": "./translations/es-ES.json",
     "./babel-plugin-csf-to-jest": "./babel-plugin-csf-to-jest.js"
   },
+  "bin": {
+    "run-transformers": "./scripts/run-transformers.js"
+  },
   "engines": {
     "node": ">=20.10.0"
   },
@@ -164,8 +167,10 @@
     "@types/react": "18.3.23",
     "@types/react-portal": "4.0.7",
     "@types/react-transition-group": "4.2.3",
+    "diff": "8.0.2",
     "expo-document-picker": "11.10.1",
     "expo-image-picker": "14.7.1",
+    "jscodeshift": "17.3.0",
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-error-boundary": "3.1.4",

package/scripts/run-transformers.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+/* eslint-disable global-require */
+/* eslint-disable import/no-dynamic-require */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { diffLines } = require('diff');
+const jscodeshift = require('jscodeshift');
+
+const args = process.argv.slice(2);
+const [targetPath] = args;
+
+// Check for --dry argument to enable dry run mode
+const isDryRun = args.includes('--dry');
+
+// Check for --only argument to run a specific transformer
+const onlyArg = args.find((arg) => arg.startsWith('--only='));
+const transformerName = onlyArg ? onlyArg.split('=')[1] : null;
+
+if (!targetPath) {
+  console.error('❌ Usage: node scripts/run-transformers.js <targetPath> [--dry] [--only=<transformerName>]');
+  process.exit(1);
+}
+
+if (!fs.existsSync(targetPath)) {
+  console.error(`❌ Path "${targetPath}" does not exist.`);
+  process.exit(1);
+}
+
+const transformsDir = path.join(__dirname, 'transformers');
+const transformFiles = fs
+  .readdirSync(transformsDir)
+  .filter((file) => file.endsWith('.js') && (!transformerName || file === `${transformerName}.js`));
+
+if (transformFiles.length === 0) {
+  console.log('✅ No transformers to apply.');
+  process.exit(0);
+}
+
+console.log(`🛠  Found ${transformFiles.length} transformer(s) to apply to: ${targetPath}`);
+
+// Utility to recursively collect all .ts/.tsx files
+function getAllFiles(dir) {
+  let results = [];
+  for (const entry of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, entry);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      results = [...results, ...getAllFiles(fullPath)];
+    } else if (fullPath.endsWith('.ts') || fullPath.endsWith('.tsx')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+const filesToTransform = fs.statSync(targetPath).isDirectory() ? getAllFiles(targetPath) : [targetPath];
+const updatedFiles = new Set();
+
+// Execute each transformer
+for (const transformFile of transformFiles) {
+  const transformPath = path.join(transformsDir, transformFile);
+  const transformer = require(transformPath);
+  console.log(`➡️  Running transformer: ${transformFile}`);
+
+  for (const filePath of filesToTransform) {
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    try {
+      const transformed = transformer(
+        { path: filePath, source },
+        { jscodeshift: jscodeshift.withParser('tsx') },
+        { printOptions: { quote: 'single', trailingComma: true } },
+      );
+
+      if (typeof transformed === 'string' && transformed !== source) {
+        if (isDryRun) {
+          console.log(`🔍 ${filePath}`);
+          const diff = diffLines(source, transformed);
+          diff.forEach((part) => {
+            const color = part.added ? '\u001B[32m' : part.removed ? '\u001B[31m' : '\u001B[0m';
+            const prefix = part.added ? '+' : part.removed ? '-' : ' ';
+            const lines = part.value.split('\n').map((line) => `${prefix} ${line}`);
+            process.stdout.write(`${color}${lines.join('\n')}\u001B[0m\n`);
+          });
+        } else {
+          fs.writeFileSync(filePath, transformed, 'utf8');
+          console.log(`✅ Updated: ${filePath}`);
+        }
+
+        updatedFiles.add(filePath);
+      }
+    } catch (error) {
+      if (error.message.includes('TSSatisfiesExpression')) {
+        console.warn(`⚠️ Skipping unsupported file (satisfies): ${filePath}`);
+      } else {
+        console.error(`❌ Error transforming ${filePath}:`, error.message);
+      }
+    }
+  }
+
+  console.log(`✅ Finished: ${transformFile}\n`);
+}
+
+if (isDryRun) {
+  console.log(`🚧 Dry run complete. ${updatedFiles.size} file(s) would be modified.`);
+  console.log('Run without --dry to apply changes.');
+} else {
+  console.log(`🏁 All transformers done. ${updatedFiles.size} file(s) modified.`);
+}

package/scripts/transformers/modals.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/* eslint-disable prefer-destructuring */
+/* eslint-disable unicorn/no-array-method-this-argument */
+
+// Use local jscodeshift instance directly
+const jscodeshift = require('jscodeshift');
+
+// List of modal component names we want to transform
+const MODAL_COMPONENTS = ['FullscreenModal', 'CardModal', 'NavigationModal'];
+
+module.exports = function transformer(fileInfo, api) {
+  // Use the jscodeshift API to parse the file
+  const j = api.jscodeshift || jscodeshift;
+
+  // Parse the source code of the file
+  const root = j(fileInfo.source);
+
+  // Iterate over each modal component found in the source code
+  MODAL_COMPONENTS.forEach((componentName) => {
+    // Find instances of the modal component
+    root
+      .find(j.JSXElement, {
+        openingElement: {
+          name: { type: 'JSXIdentifier', name: componentName },
+        },
+      })
+      .forEach((path) => {
+        // Get the node (the JSXElement) from the path
+        const node = path.node;
+
+        // Check if the modal component already has children or if it is self-closing
+        const hasChildren = Array.isArray(node.children) && node.children.length > 0;
+        if (!node.openingElement.selfClosing && hasChildren) {
+          // If it already has children, do nothing and skip transformation
+          return;
+        }
+
+        // Extract the attributes from the JSX element (like `header`, `body`, `footer`)
+        const attributes = node.openingElement.attributes;
+
+        // Initialize a map to hold potential new children: header, body, footer
+        const newChildrenMap = {
+          header: null,
+          body: null,
+          footer: null,
+        };
+
+        // An array to keep attributes that are not `header`, `body`, or `footer`
+        const keptAttributes = [];
+
+        // Loop over the attributes to check if any match `header`, `body`, or `footer`
+        attributes.forEach((attr) => {
+          if (
+            attr.type === 'JSXAttribute' &&
+            attr.name &&
+            Object.prototype.hasOwnProperty.call(newChildrenMap, attr.name.name)
+          ) {
+            const key = attr.name.name;
+            const value = attr.value;
+
+            // Check if the value of the attribute is an expression (like a ternary)
+            if (value?.type === 'JSXExpressionContainer') {
+              const expression = value.expression;
+
+              // If it's a JSXElement or JSXFragment, keep it as it is
+              if (j.JSXElement.check(expression) || j.JSXFragment.check(expression)) {
+                newChildrenMap[key] = expression;
+              } else {
+                // Otherwise, wrap it in an expression container to handle non-JSX expressions
+                newChildrenMap[key] = j.jsxExpressionContainer(expression);
+              }
+            }
+          } else {
+            // Keep any other attributes (that are not header/body/footer)
+            keptAttributes.push(attr);
+          }
+        });
+
+        // If no new children were found (no `header`, `body`, or `footer`), do nothing
+        if (Object.values(newChildrenMap).every((v) => v === null)) {
+          return;
+        }
+
+        // If the modal component was self-closing, convert it to a regular JSX element with children
+        if (node.openingElement.selfClosing) {
+          node.openingElement.selfClosing = false;
+          node.closingElement = j.jsxClosingElement(j.jsxIdentifier(node.openingElement.name.name));
+        }
+
+        // Retain all the other attributes and set the new ones
+        node.openingElement.attributes = keptAttributes;
+
+        // Force the order of children: header → body → footer
+        const orderedChildren = Object.values(newChildrenMap).filter(Boolean);
+        node.children = orderedChildren;
+      });
+  });
+
+  // Return the modified source code after transformation
+  return root.toSource({ quote: 'single' });
+};