ingeniuscliq-core 0.4.15 → 0.4.16

package/src/core/commands/create-template.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+import { createBaseDir, joinPaths } from './helpers/index.js';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import fs from 'fs';
+
+const { prompt } = enquirer;
+
+function sanitizeTemplateName(input) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '-')      // espacios -> guiones
+    .replace(/[^a-z0-9-]/g, '') // solo [a-z0-9-]
+    .replace(/-+/g, '-');       // colapsar guiones
+}
+
+function toPascalCase(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function createTemplate(templateNameRaw) {
+  const templateName = sanitizeTemplateName(templateNameRaw);
+
+  if (!templateName) {
+    console.error(chalk.red.bold('❌ Error: El nombre de la plantilla es requerido.'));
+    process.exit(1);
+  }
+
+  // Base: <cwd>/components/templates/<templateName>
+  const baseDir = createBaseDir(templateName, ['src', 'components', 'templates']);
+
+  if (fs.existsSync(baseDir)) {
+    console.error(chalk.red.bold(`❌ Error: La plantilla '${templateName}' ya existe en components/templates.`));
+    process.exit(1);
+  }
+
+  try {
+    // Asegurar carpetas padre
+    ensureDir(createBaseDir('', ['src', 'components']));           // <cwd>/components
+    ensureDir(createBaseDir('', ['src', 'components', 'templates'])); // <cwd>/components/templates
+
+    // Crear carpeta de la plantilla
+    ensureDir(baseDir);
+    console.log(chalk.green(`✓ Creado directorio: ${chalk.bold(`src/components/templates/${templateName}`)}`));
+
+    // Subcarpetas requeridas
+    const subdirs = ['components', 'pages', 'styles', 'assets', 'helpers', 'hooks', 'types', 'locale'];
+    subdirs.forEach((dir) => {
+      ensureDir(joinPaths(baseDir, dir));
+      console.log(chalk.green(`✓ Creado directorio: ${chalk.bold(`src/components/templates/${templateName}/${dir}`)}`));
+    });
+
+    // Subcarpetas dentro de components
+    const componentsSubdirs = ['common', 'skeletons', 'layout'];
+    componentsSubdirs.forEach((dir) => {
+      ensureDir(joinPaths(baseDir, 'components', dir));
+      console.log(chalk.green(`✓ Creado directorio: ${chalk.bold(`src/components/templates/${templateName}/components/${dir}`)}`));
+    });
+
+    // Subcarpetas dentro de pages con archivos index.tsx
+    const pagesSubdirs = ['store', 'preview'];
+    const pageTemplates = {
+      store: `const StorePage = () => {\n  return (\n    <></>\n  )\n}\n\nexport default StorePage\n`,
+      preview: `const PreviewPage = () => {\n  return (\n    <></>\n  )\n}\n\nexport default PreviewPage\n`
+    };
+
+    pagesSubdirs.forEach((dir) => {
+      const pageDirPath = joinPaths(baseDir, 'pages', dir);
+      ensureDir(pageDirPath);
+      console.log(chalk.green(`✓ Creado directorio: ${chalk.bold(`src/components/templates/${templateName}/pages/${dir}`)}`));
+      
+      // Crear archivo index.tsx
+      const indexPath = joinPaths(pageDirPath, 'index.tsx');
+      fs.writeFileSync(indexPath, pageTemplates[dir]);
+      console.log(chalk.green(`✓ Creado archivo: ${chalk.bold(`src/components/templates/${templateName}/pages/${dir}/index.tsx`)}`));
+    });
+
+    // Archivos dentro de components/layout
+    const pascalCaseName = toPascalCase(templateName);
+    const layoutDir = joinPaths(baseDir, 'components', 'layout');
+    
+    // index.tsx en layout
+    const layoutIndexContent = `const ${pascalCaseName}Layout = ({ children }: { children: React.ReactNode }) => {\n  return (\n    <></>\n  )\n}\n\nexport default ${pascalCaseName}Layout\n`;
+    const layoutIndexPath = joinPaths(layoutDir, 'index.tsx');
+    fs.writeFileSync(layoutIndexPath, layoutIndexContent);
+    console.log(chalk.green(`✓ Creado archivo: ${chalk.bold(`src/components/templates/${templateName}/components/layout/index.tsx`)}`));
+    
+    // preview.tsx en layout
+    const layoutPreviewContent = `interface ${pascalCaseName}PreviewLayoutProps extends React.PropsWithChildren {\n  template?: string | null\n}\n\nconst ${pascalCaseName}PreviewLayout = ({ template = null, children }: ${pascalCaseName}PreviewLayoutProps) => {\n  return (\n    <></>\n  )\n}\n\nexport default ${pascalCaseName}PreviewLayout\n`;
+    const layoutPreviewPath = joinPaths(layoutDir, 'preview.tsx');
+    fs.writeFileSync(layoutPreviewPath, layoutPreviewContent);
+    console.log(chalk.green(`✓ Creado archivo: ${chalk.bold(`src/components/templates/${templateName}/components/layout/preview.tsx`)}`));
+
+    // Estructura de locale
+    const localeDir = joinPaths(baseDir, 'locale');
+    const localeSubdirs = ['fields', 'messages'];
+    const localeFiles = ['en.json', 'es.json'];
+    const emptyJsonContent = '{}\n';
+    
+    // Archivos en locale raíz
+    localeFiles.forEach((file) => {
+      const filePath = joinPaths(localeDir, file);
+      fs.writeFileSync(filePath, emptyJsonContent);
+      console.log(chalk.green(`✓ Creado archivo: ${chalk.bold(`src/components/templates/${templateName}/locale/${file}`)}`));
+    });
+    
+    // Subcarpetas y archivos en locale
+    localeSubdirs.forEach((subdir) => {
+      const subdirPath = joinPaths(localeDir, subdir);
+      ensureDir(subdirPath);
+      console.log(chalk.green(`✓ Creado directorio: ${chalk.bold(`src/components/templates/${templateName}/locale/${subdir}`)}`));
+      
+      localeFiles.forEach((file) => {
+        const filePath = joinPaths(subdirPath, file);
+        fs.writeFileSync(filePath, emptyJsonContent);
+        console.log(chalk.green(`✓ Creado archivo: ${chalk.bold(`src/components/templates/${templateName}/locale/${subdir}/${file}`)}`));
+      });
+    });
+
+    console.log(chalk.green.bold(`\n✨ Plantilla '${templateName}' creada correctamente.`));
+  } catch (error) {
+    console.error(chalk.red.bold(`❌ Error creando la plantilla: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+async function promptTemplateName() {
+  console.log(chalk.cyan.bold('\n==================================='));
+  console.log(chalk.cyan.bold('          Create Template'));
+  console.log(chalk.cyan.bold('===================================\n'));
+
+  const { templateName } = await prompt({
+    type: 'input',
+    name: 'templateName',
+    message: 'Ingresa el nombre de la plantilla:',
+    validate: (input) => {
+      const val = sanitizeTemplateName(input);
+      if (!val) return 'El nombre es requerido.';
+      const target = createBaseDir(val, ['src', 'components', 'templates']);
+      if (fs.existsSync(target)) return `La plantilla '${val}' ya existe.`;
+      return true;
+    },
+  });
+
+  return templateName;
+}
+
+// CLI
+const templateNameArg = process.argv[2];
+
+(async function main() {
+  let name = templateNameArg;
+  if (!name) {
+    name = await promptTemplateName();
+  }
+  createTemplate(name);
+})().catch((err) => {
+  console.error(chalk.red.bold(`❌ Error inesperado: ${err.message}`));
+  process.exit(1);
+});

package/src/core/commands/rollback-core-module.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+import { createBaseDir, joinPaths } from './helpers/index.js';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import fs from 'fs';
+import path from 'path';
+
+const { prompt } = enquirer;
+
+/**
+ * Removes the module import from the modules/index.ts file
+ * @param {string} moduleName The name of the module to remove
+ */
+function removeModuleImport(moduleName) {
+  const modulesDir = createBaseDir('modules', ['core']);
+  const indexPath = joinPaths(modulesDir, 'index.ts');
+
+  try {
+    if (fs.existsSync(indexPath)) {
+      let content = fs.readFileSync(indexPath, 'utf8');
+      const importStatement = `import './${moduleName}'`;
+      
+      // Remove the import line if it exists
+      const lines = content.split('\n').filter(line => !line.includes(importStatement));
+      
+      // Clean up empty lines between imports
+      let cleanedLines = [];
+      let lastLineWasEmpty = false;
+      
+      for (const line of lines) {
+        if (line.trim() === '') {
+          if (!lastLineWasEmpty) {
+            cleanedLines.push(line);
+            lastLineWasEmpty = true;
+          }
+        } else {
+          cleanedLines.push(line);
+          lastLineWasEmpty = false;
+        }
+      }
+      
+      content = cleanedLines.join('\n');
+      
+      fs.writeFileSync(indexPath, content);
+      console.log(chalk.green(`✓ Removed module import from ${chalk.bold('modules/index.ts')}`));
+    }
+  } catch (error) {
+    console.error(chalk.yellow(`⚠️ Warning: Could not update modules index: ${error.message}`));
+  }
+}
+
+/**
+ * Recursively removes a directory and its contents
+ * @param {string} dirPath The path to the directory to remove
+ */
+function removeDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    fs.readdirSync(dirPath).forEach((file) => {
+      const curPath = path.join(dirPath, file);
+      if (fs.lstatSync(curPath).isDirectory()) {
+        removeDirectory(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(dirPath);
+  }
+}
+
+/**
+ * Rolls back a core module creation
+ * @param {string} moduleName The name of the module to roll back
+ */
+async function rollbackModule(moduleName) {
+  if (!moduleName) {
+    console.error(chalk.red.bold('❌ Error: Core module name is required'));
+    console.log(chalk.yellow('⚠️ Usage: npm run rollback:core-module <module-name>'));
+    process.exit(1);
+  }
+
+  const baseDir = createBaseDir(moduleName, ['core', 'modules']);
+
+  // Check if module exists
+  if (!fs.existsSync(baseDir)) {
+    console.error(chalk.red.bold(`❌ Error: Core module '${moduleName}' does not exist`));
+    process.exit(1);
+  }
+
+  try {
+    // Ask for confirmation
+    const response = await prompt({
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.yellow(`⚠️ Are you sure you want to delete the module '${moduleName}'? This action cannot be undone.`),
+      initial: false
+    });
+
+    if (!response.confirm) {
+      console.log(chalk.yellow('Operation cancelled.'));
+      process.exit(0);
+    }
+
+    // Remove the module directory
+    removeDirectory(baseDir);
+    console.log(chalk.green(`✓ Removed module directory: ${chalk.bold(moduleName)}`));
+
+    // Remove the module import from index.ts
+    removeModuleImport(moduleName);
+
+    console.log(chalk.green.bold(`\n✨ Module '${moduleName}' successfully removed`));
+  } catch (error) {
+    if (error.message !== 'USER_CANCELLED') {
+      console.error(chalk.red.bold(`❌ Error rolling back module: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Lists all available core modules
+ * @returns {string[]} Array of module names
+ */
+function listAvailableModules() {
+  const modulesDir = createBaseDir('modules', ['core']);
+  
+  try {
+    if (fs.existsSync(modulesDir)) {
+      return fs.readdirSync(modulesDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    }
+  } catch (error) {
+    console.error(chalk.yellow(`⚠️ Warning: Could not read modules directory: ${error.message}`));
+  }
+  
+  return [];
+}
+
+/**
+ * Prompts the user to select a module to roll back
+ */
+async function promptModuleSelection() {
+  const modules = listAvailableModules();
+
+  if (modules.length === 0) {
+    console.error(chalk.red.bold('❌ Error: No core modules found'));
+    process.exit(1);
+  }
+
+  try {
+    const response = await prompt({
+      type: 'select',
+      name: 'moduleName',
+      message: 'Select the module to roll back:',
+      choices: modules.map(module => ({
+        name: module,
+        value: module,
+        message: module
+      })),
+      styles: {
+        primary: chalk.cyan,
+        highlight: chalk.cyan.bold,
+        selected: chalk.red.bold
+      }
+    });
+
+    return response.moduleName;
+  } catch (error) {
+    console.log(chalk.yellow('⚠️ Operation cancelled.'));
+    process.exit(0);
+  }
+}
+
+// Get module name from command line arguments or prompt
+const moduleNameArg = process.argv[2];
+
+async function main() {
+  console.log(chalk.red.bold('\n==================================='));
+  console.log(chalk.red.bold('         Rollback Core Module'));
+  console.log(chalk.red.bold('===================================\n'));
+
+  let moduleName = moduleNameArg;
+  
+  if (!moduleName) {
+    moduleName = await promptModuleSelection();
+  }
+  
+  await rollbackModule(moduleName);
+}
+
+main().catch(error => {
+  console.error(chalk.red.bold(`❌ Unexpected error: ${error.message}`));
+  process.exit(1);
+});

package/src/core/commands/rollback-module.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+import { createBaseDir, joinPaths } from './helpers/index.js';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import fs from 'fs';
+import path from 'path';
+
+const { prompt } = enquirer;
+
+/**
+ * Removes the module import from the modules/index.ts file if it exists
+ * @param {string} moduleName The name of the module to remove
+ */
+function removeModuleImport(moduleName) {
+  const modulesDir = createBaseDir('modules', ['src']);
+  const indexPath = joinPaths(modulesDir, 'index.ts');
+
+  try {
+    if (fs.existsSync(indexPath)) {
+      let content = fs.readFileSync(indexPath, 'utf8');
+      const importStatement = `import './${moduleName}'`;
+      
+      // Remove the import line if it exists
+      const lines = content.split('\n').filter(line => !line.includes(importStatement));
+      
+      // Clean up empty lines between imports
+      let cleanedLines = [];
+      let lastLineWasEmpty = false;
+      
+      for (const line of lines) {
+        if (line.trim() === '') {
+          if (!lastLineWasEmpty) {
+            cleanedLines.push(line);
+            lastLineWasEmpty = true;
+          }
+        } else {
+          cleanedLines.push(line);
+          lastLineWasEmpty = false;
+        }
+      }
+      
+      content = cleanedLines.join('\n');
+      
+      fs.writeFileSync(indexPath, content);
+      console.log(chalk.green(`✓ Removed module import from ${chalk.bold('modules/index.ts')}`));
+    }
+  } catch (error) {
+    console.error(chalk.yellow(`⚠️ Warning: Could not update modules index: ${error.message}`));
+  }
+}
+
+/**
+ * Recursively removes a directory and its contents
+ * @param {string} dirPath The path to the directory to remove
+ */
+function removeDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    fs.readdirSync(dirPath).forEach((file) => {
+      const curPath = path.join(dirPath, file);
+      if (fs.lstatSync(curPath).isDirectory()) {
+        removeDirectory(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+    fs.rmdirSync(dirPath);
+  }
+}
+
+/**
+ * Rolls back a module creation
+ * @param {string} moduleName The name of the module to roll back
+ */
+async function rollbackModule(moduleName) {
+  if (!moduleName) {
+    console.error(chalk.red.bold('❌ Error: Module name is required'));
+    console.log(chalk.yellow('⚠️ Usage: npm run rollback:module <module-name>'));
+    process.exit(1);
+  }
+
+  const baseDir = createBaseDir(moduleName, ['src', 'modules']);
+
+  // Check if module exists
+  if (!fs.existsSync(baseDir)) {
+    console.error(chalk.red.bold(`❌ Error: Module '${moduleName}' does not exist`));
+    process.exit(1);
+  }
+
+  try {
+    // Ask for confirmation with module details
+    console.log(chalk.yellow('\nModule details:'));
+    console.log(chalk.yellow('─────────────────'));
+    console.log(chalk.yellow(`Location: ${baseDir}`));
+    
+    // Show module contents
+    const contents = fs.readdirSync(baseDir, { withFileTypes: true });
+    console.log(chalk.yellow('Contents:'));
+    contents.forEach(item => {
+      const prefix = item.isDirectory() ? '📁' : '📄';
+      console.log(chalk.yellow(`  ${prefix} ${item.name}`));
+    });
+    console.log(chalk.yellow('─────────────────\n'));
+
+    const response = await prompt({
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.yellow(`⚠️ Are you sure you want to delete this module? This action cannot be undone.`),
+      initial: false
+    });
+
+    if (!response.confirm) {
+      console.log(chalk.yellow('Operation cancelled.'));
+      process.exit(0);
+    }
+
+    // Remove the module directory
+    removeDirectory(baseDir);
+    console.log(chalk.green(`✓ Removed module directory: ${chalk.bold(moduleName)}`));
+
+    // Remove the module import from index.ts
+    removeModuleImport(moduleName);
+
+    console.log(chalk.green.bold(`\n✨ Module '${moduleName}' successfully removed`));
+  } catch (error) {
+    if (error.message !== 'USER_CANCELLED') {
+      console.error(chalk.red.bold(`❌ Error rolling back module: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Lists all available modules
+ * @returns {string[]} Array of module names
+ */
+function listAvailableModules() {
+  const modulesDir = createBaseDir('modules', ['src']);
+  
+  try {
+    if (fs.existsSync(modulesDir)) {
+      return fs.readdirSync(modulesDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    }
+  } catch (error) {
+    console.error(chalk.yellow(`⚠️ Warning: Could not read modules directory: ${error.message}`));
+  }
+  
+  return [];
+}
+
+/**
+ * Prompts the user to select a module to roll back
+ */
+async function promptModuleSelection() {
+  const modules = listAvailableModules();
+
+  if (modules.length === 0) {
+    console.error(chalk.red.bold('❌ Error: No modules found'));
+    process.exit(1);
+  }
+
+  try {
+    const response = await prompt({
+      type: 'select',
+      name: 'moduleName',
+      message: 'Select the module to roll back:',
+      choices: modules.map(module => ({
+        name: module,
+        value: module,
+        message: module
+      })),
+      styles: {
+        primary: chalk.cyan,
+        highlight: chalk.cyan.bold,
+        selected: chalk.red.bold
+      }
+    });
+
+    return response.moduleName;
+  } catch (error) {
+    console.log(chalk.yellow('⚠️ Operation cancelled.'));
+    process.exit(0);
+  }
+}
+
+// Get module name from command line arguments or prompt
+const moduleNameArg = process.argv[2];
+
+async function main() {
+  console.log(chalk.red.bold('\n==================================='));
+  console.log(chalk.red.bold('           Rollback Module'));
+  console.log(chalk.red.bold('===================================\n'));
+
+  let moduleName = moduleNameArg;
+  
+  if (!moduleName) {
+    moduleName = await promptModuleSelection();
+  }
+  
+  await rollbackModule(moduleName);
+}
+
+main().catch(error => {
+  console.error(chalk.red.bold(`❌ Unexpected error: ${error.message}`));
+  process.exit(1);
+});

package/dist/node_modules/@radix-ui/react-accordion/node_modules/@radix-ui/react-collapsible/node_modules/@radix-ui/react-presence/dist/index.js

@@ -1,130 +0,0 @@
-import * as React from 'react';
-import { useComposedRefs } from '../../../../../../../../react-compose-refs/dist/index.js';
-import { useLayoutEffect as useLayoutEffect2 } from '../../../../../../../../react-use-layout-effect/dist/index.js';
-
-function useStateMachine(initialState, machine) {
-  return React.useReducer((state, event) => {
-    const nextState = machine[state][event];
-    return nextState ?? state;
-  }, initialState);
-}
-
-// src/presence.tsx
-var Presence = (props) => {
-  const { present, children } = props;
-  const presence = usePresence(present);
-  const child = typeof children === "function" ? children({ present: presence.isPresent }) : React.Children.only(children);
-  const ref = useComposedRefs(presence.ref, getElementRef(child));
-  const forceMount = typeof children === "function";
-  return forceMount || presence.isPresent ? React.cloneElement(child, { ref }) : null;
-};
-Presence.displayName = "Presence";
-function usePresence(present) {
-  const [node, setNode] = React.useState();
-  const stylesRef = React.useRef(null);
-  const prevPresentRef = React.useRef(present);
-  const prevAnimationNameRef = React.useRef("none");
-  const initialState = present ? "mounted" : "unmounted";
-  const [state, send] = useStateMachine(initialState, {
-    mounted: {
-      UNMOUNT: "unmounted",
-      ANIMATION_OUT: "unmountSuspended"
-    },
-    unmountSuspended: {
-      MOUNT: "mounted",
-      ANIMATION_END: "unmounted"
-    },
-    unmounted: {
-      MOUNT: "mounted"
-    }
-  });
-  React.useEffect(() => {
-    const currentAnimationName = getAnimationName(stylesRef.current);
-    prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
-  }, [state]);
-  useLayoutEffect2(() => {
-    const styles = stylesRef.current;
-    const wasPresent = prevPresentRef.current;
-    const hasPresentChanged = wasPresent !== present;
-    if (hasPresentChanged) {
-      const prevAnimationName = prevAnimationNameRef.current;
-      const currentAnimationName = getAnimationName(styles);
-      if (present) {
-        send("MOUNT");
-      } else if (currentAnimationName === "none" || styles?.display === "none") {
-        send("UNMOUNT");
-      } else {
-        const isAnimating = prevAnimationName !== currentAnimationName;
-        if (wasPresent && isAnimating) {
-          send("ANIMATION_OUT");
-        } else {
-          send("UNMOUNT");
-        }
-      }
-      prevPresentRef.current = present;
-    }
-  }, [present, send]);
-  useLayoutEffect2(() => {
-    if (node) {
-      let timeoutId;
-      const ownerWindow = node.ownerDocument.defaultView ?? window;
-      const handleAnimationEnd = (event) => {
-        const currentAnimationName = getAnimationName(stylesRef.current);
-        const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
-        if (event.target === node && isCurrentAnimation) {
-          send("ANIMATION_END");
-          if (!prevPresentRef.current) {
-            const currentFillMode = node.style.animationFillMode;
-            node.style.animationFillMode = "forwards";
-            timeoutId = ownerWindow.setTimeout(() => {
-              if (node.style.animationFillMode === "forwards") {
-                node.style.animationFillMode = currentFillMode;
-              }
-            });
-          }
-        }
-      };
-      const handleAnimationStart = (event) => {
-        if (event.target === node) {
-          prevAnimationNameRef.current = getAnimationName(stylesRef.current);
-        }
-      };
-      node.addEventListener("animationstart", handleAnimationStart);
-      node.addEventListener("animationcancel", handleAnimationEnd);
-      node.addEventListener("animationend", handleAnimationEnd);
-      return () => {
-        ownerWindow.clearTimeout(timeoutId);
-        node.removeEventListener("animationstart", handleAnimationStart);
-        node.removeEventListener("animationcancel", handleAnimationEnd);
-        node.removeEventListener("animationend", handleAnimationEnd);
-      };
-    } else {
-      send("ANIMATION_END");
-    }
-  }, [node, send]);
-  return {
-    isPresent: ["mounted", "unmountSuspended"].includes(state),
-    ref: React.useCallback((node2) => {
-      stylesRef.current = node2 ? getComputedStyle(node2) : null;
-      setNode(node2);
-    }, [])
-  };
-}
-function getAnimationName(styles) {
-  return styles?.animationName || "none";
-}
-function getElementRef(element) {
-  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
-  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
-  if (mayWarn) {
-    return element.ref;
-  }
-  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
-  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
-  if (mayWarn) {
-    return element.props.ref;
-  }
-  return element.props.ref || element.ref;
-}
-
-export { Presence };