bernova 0.0.2

package/src/constants/resetCss.js

@@ -0,0 +1,171 @@
+/**
+ * CSS Reset for Bernova
+ *
+ * Provides a comprehensive CSS reset that normalizes default browser styles.
+ * Based on modern reset principles, ensures consistent cross-browser rendering.
+ *
+ * Features:
+ * - Removes default margins and padding
+ * - Sets consistent box-sizing
+ * - Normalizes form elements
+ * - Resets list styles
+ * - Standardizes table presentation
+ *
+ * This reset is optional and can be enabled via the `resetCss` flag in theme configuration.
+ */
+const resetCss = `
+html {
+  margin: 0;
+  padding: 0;
+  vertical-align: baseline;
+  margin-block-start: 0;
+  margin-block-end: 0;
+  margin-inline-start: 0;
+  margin-inline-end: 0;
+  box-sizing: border-box;
+  background-color: transparent;
+  border: 0;
+}
+body,
+div,
+span,
+applet,
+object,
+iframe,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+p,
+blockquote,
+pre,
+a,
+abbr,
+acronym,
+address,
+big,
+cite,
+code,
+del,
+dfn,
+em,
+img,
+ins,
+kbd,
+q,
+s,
+samp,
+small,
+strike,
+strong,
+sub,
+sup,
+tt,
+var,
+b,
+u,
+i,
+center,
+dl,
+dt,
+dd,
+ol,
+ul,
+li,
+fieldset,
+form,
+label,
+legend,
+table,
+caption,
+tbody,
+tfoot,
+thead,
+tr,
+th,
+td,
+article,
+aside,
+canvas,
+details,
+embed,
+figure,
+figcaption,
+footer,
+header,
+hgroup,
+menu,
+nav,
+output,
+ruby,
+section,
+summary,
+time,
+mark,
+audio,
+video,
+dialog,
+input,
+button {
+  margin: 0;
+  padding: 0;
+  vertical-align: baseline;
+  margin-block-start: 0;
+  margin-block-end: 0;
+  margin-inline-start: 0;
+  margin-inline-end: 0;
+  box-sizing: border-box;
+  background-color: transparent;
+  border: 0;
+}
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+menu,
+nav,
+section {
+  display: block;
+}
+body {
+  line-height: 1;
+}
+ol,
+ul {
+  list-style: none;
+}
+blockquote,
+q {
+  quotes: none;
+}
+blockquote::before,
+blockquote::after,
+q::before,
+q::after {
+  content: "";
+  content: none;
+}
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+@supports (font: -apple-system-body) {
+  html {
+    font: -apple-system-body;
+  }
+}
+@supports (font: system-ui) {
+  html {
+    font: system-ui;
+  }
+}
+`;
+
+module.exports = { resetCss };

package/src/index.d.ts

@@ -0,0 +1,31 @@
+// Type definitions for Bernova
+export interface BernovaConfig {
+  themes: any[];
+  provider?: {
+    path: string;
+    name: string;
+    declarationHelp?: boolean;
+  };
+}
+
+export interface BernovaTheme {
+  name: string;
+  stylesPath?: string;
+  [key: string]: any;
+}
+
+// Main Bernova function
+export function bernovaStyles(compilerType?: string): Promise<void>;
+
+// Library exports
+export const lib: any;
+export const constants: any;
+
+// Default export
+declare const bernova: {
+  bernovaStyles: typeof bernovaStyles;
+  lib: typeof lib;
+  constants: typeof constants;
+};
+
+export default bernova;

package/src/index.js

@@ -0,0 +1,20 @@
+// Main entry point for Bernova package
+const lib = require('./lib');
+const constants = require('./constants');
+const { bernovaStyles } = require('./app');
+
+// Export the main functionality
+module.exports = {
+  // Main function
+  bernovaStyles,
+
+  // Library functions
+  ...lib,
+
+  // Constants
+  ...constants,
+
+  // Direct access to modules
+  lib,
+  constants,
+};

package/src/lib/compileConfig.js

@@ -0,0 +1,59 @@
+const path = require('path');
+const tsConfigPaths = require('tsconfig-paths');
+const { readConfigData } = require('./readFile/readFile.utils.js');
+
+/**
+ * Compiles and validates the Bernova configuration from bernova.config.json
+ * Sets up TypeScript path mapping if configured
+ *
+ * @param {Object} params - The parameters object
+ * @param {string} params.dir - The project directory containing the configuration file
+ * @returns {Promise<Object>} Configuration object containing themes and provider settings
+ * @throws {Error} When configuration file is invalid or missing
+ */
+const compileConfig = async ({ dir }) => {
+  try {
+    const configDir = path.resolve(dir, 'bernova.config.json');
+    const configData = await readConfigData(configDir);
+
+    if (!configData) {
+      throw new Error(`Configuration file not found at ${configDir}`);
+    }
+
+    const { themes, provider, tsconfigPath } = configData;
+
+    // Validate required configuration
+    if (!themes || !Array.isArray(themes) || themes.length === 0) {
+      throw new Error('Configuration must include at least one theme');
+    }
+
+    // Setup TypeScript path mapping if configured
+    if (tsconfigPath) {
+      try {
+        const tsConfig = path.resolve(dir, tsconfigPath);
+        const tsConfigData = await readConfigData(tsConfig);
+
+        if (tsConfigData?.compilerOptions) {
+          tsConfigPaths.register({
+            baseUrl: tsConfigData.compilerOptions.baseUrl || dir,
+            paths: tsConfigData.compilerOptions.paths || {},
+          });
+          console.log(`TypeScript paths configured from ${tsconfigPath}`);
+        } else {
+          console.warn(`Invalid or empty tsconfig at ${tsconfigPath}`);
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to load TypeScript configuration: ${error.message}`
+        );
+      }
+    }
+
+    return { themes, provider };
+  } catch (error) {
+    console.error('Failed to compile configuration:', error.message);
+    throw error;
+  }
+};
+
+module.exports = { compileConfig };

package/src/lib/compileThemes.js

@@ -0,0 +1,118 @@
+/**
+ * Theme Compilation Module for Bernova
+ *
+ * Compiles theme configurations by resolving file paths and loading theme data.
+ * Validates file existence and structures theme data for CSS generation.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { readThemeData } = require('./readFile/readFile.utils');
+const { fileExists } = require('./fileExists/fileExists.utils');
+
+/**
+ * Compiles a theme configuration by loading and validating theme files
+ *
+ * @param {Object} params - Compilation parameters
+ * @param {Object} params.themeConfig - Theme configuration object
+ * @param {string} params.themeConfig.name - Theme name (defaults to 'bernova')
+ * @param {string} params.themeConfig.prefix - CSS variable prefix
+ * @param {Object} params.themeConfig.theme - Theme styles configuration
+ * @param {Object} params.themeConfig.foundations - Foundation styles configuration
+ * @param {Object} params.themeConfig.globalStyles - Global styles configuration
+ * @param {Object} params.themeConfig.mediaQueries - Media queries configuration
+ * @param {string} params.themeConfig.stylesPath - Output path for generated styles
+ * @param {Array} params.themeConfig.fonts - Font configurations
+ * @param {boolean} params.themeConfig.resetCss - Whether to include CSS reset
+ * @param {Object} params.themeConfig.bvTools - Development tools configuration
+ * @param {Object} params.themeConfig.typesTools - TypeScript tools configuration
+ * @param {Array} params.themeConfig.foreignThemes - External theme integrations
+ * @param {string} params.dir - Base directory for resolving relative paths
+ * @returns {Object} Compiled theme data and configuration
+ */
+const compileThemes = ({
+  themeConfig: {
+    name = 'bernova',
+    prefix,
+    theme,
+    foundations,
+    globalStyles,
+    mediaQueries,
+    stylesPath,
+    fonts,
+    resetCss,
+    bvTools,
+    typesTools,
+    foreignThemes,
+  },
+  dir,
+}) => {
+  // Resolve and validate theme file paths
+  const paths = (() => {
+    const resolvedPaths = {};
+
+    // Process foundations (CSS variables, base tokens)
+    if (
+      foundations?.name &&
+      foundations?.path &&
+      fileExists(dir, foundations.path)
+    ) {
+      resolvedPaths.foundations = {
+        path: path.resolve(dir, foundations.path),
+        name: foundations.name,
+      };
+    }
+
+    // Process theme styles (component styles, utilities)
+    if (theme?.name && theme?.path && fileExists(dir, theme.path)) {
+      resolvedPaths.theme = {
+        path: path.resolve(dir, theme.path),
+        name: theme.name,
+      };
+    }
+
+    // Process global styles (CSS resets, base element styles)
+    if (
+      globalStyles?.name &&
+      globalStyles?.path &&
+      fileExists(dir, globalStyles.path)
+    ) {
+      resolvedPaths.global = {
+        path: path.resolve(dir, globalStyles.path),
+        name: globalStyles.name,
+      };
+    }
+
+    // Process media queries (responsive breakpoints)
+    if (
+      mediaQueries?.name &&
+      mediaQueries?.path &&
+      fileExists(dir, mediaQueries.path)
+    ) {
+      resolvedPaths.media = {
+        path: path.resolve(dir, mediaQueries.path),
+        name: mediaQueries.name,
+      };
+    }
+
+    return resolvedPaths;
+  })();
+
+  // Load theme data from resolved file paths
+  const themeCss = readThemeData(paths);
+
+  // Return compiled theme configuration
+  return {
+    themeCss, // Loaded CSS-in-JS theme data
+    fonts, // Font configuration
+    resetCss, // CSS reset flag
+    bvTools, // Development tools configuration
+    name, // Theme name
+    stylesPath, // Output directory for generated CSS
+    typesTools, // TypeScript generation tools
+    prefix, // CSS variable prefix
+    foreignThemes, // External theme dependencies
+  };
+};
+
+module.exports = { compileThemes };

package/src/lib/copyLocalFonts/copyLocalFonts.utils.js

@@ -0,0 +1,42 @@
+const path = require('path');
+const fs = require('fs').promises;
+
+/**
+ * Copies local font files to the output directory.
+ *
+ * @param {Array} localFonts - The local fonts configuration.
+ * @param {string} outputDir - The output directory.
+ */
+const copyLocalFonts = async (localFonts, outputDir) => {
+  if (!localFonts || localFonts.length === 0) {
+    console.log('No local fonts to copy.');
+    return;
+  }
+  const { default: ora } = await import('ora');
+  const spinner = ora('Copying local fonts...').start();
+
+  try {
+    for (const font of localFonts) {
+      for (const weight in font.files) {
+        const srcPath = path.resolve(font.files[weight]);
+        const destDir = path.resolve(outputDir, 'fonts');
+        const destPath = path.resolve(
+          destDir,
+          path.basename(font.files[weight])
+        );
+
+        // Ensure the destination directory exists
+        await fs.mkdir(destDir, { recursive: true });
+
+        // Copy the font file
+        await fs.copyFile(srcPath, destPath);
+        spinner.succeed(`Copied ${srcPath} to ${destPath}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail('Failed to copy local fonts.');
+    console.error(error);
+  }
+};
+
+module.exports = { copyLocalFonts };

package/src/lib/copyLocalFonts/generateCssFonts.utils.js

@@ -0,0 +1,56 @@
+/**
+ * CSS Font Generator for Bernova CSS Framework
+ *
+ * Generates CSS font declarations for both Google Fonts and local font files.
+ * Creates @import statements for Google Fonts and @font-face rules for local fonts.
+ */
+
+const path = require('path');
+
+/**
+ * Generates CSS font declarations from fonts configuration
+ * Supports both Google Fonts (via @import) and local fonts (via @font-face)
+ *
+ * @param {Object} fonts - Fonts configuration object
+ * @param {Array} fonts.google - Google Fonts configuration array
+ * @param {Array} fonts.local - Local fonts configuration array
+ * @returns {string} Generated CSS font declarations
+ * @example
+ * generateCssFonts({
+ *   google: [{ name: 'Roboto', weights: [400, 700] }],
+ *   local: [{ name: 'CustomFont', files: { 400: './custom.ttf' } }]
+ * })
+ */
+const generateCssFonts = (fonts) => {
+  let css = '';
+
+  // Generate Google Fonts @import statements
+  if (fonts?.google?.length) {
+    fonts.google.forEach((font) => {
+      const weights = font.weights.join(';');
+      css += `@import url('https://fonts.googleapis.com/css2?family=${font.name.replace(
+        / /g,
+        '+'
+      )}:wght@${weights}&display=swap');\n`;
+    });
+  }
+
+  // Generate local fonts @font-face declarations
+  if (fonts?.local?.length) {
+    fonts.local.forEach((font) => {
+      Object.entries(font.files).forEach(([weight, filePath]) => {
+        css += `
+  @font-face {
+    font-family: '${font.name}';
+    src: url('./fonts/${path.basename(filePath)}') format('truetype');
+    font-weight: ${weight};
+    font-style: normal;
+  }\n`;
+      });
+    });
+  }
+
+  return css;
+};
+
+module.exports = { generateCssFonts };

package/src/lib/extractDocFragment/extractDocFragment.utils.js

@@ -0,0 +1,25 @@
+/**
+ * CSS Documentation Fragment Extractor for Bernova
+ *
+ * Extracts specific sections from CSS documentation using comment markers.
+ * Used for partial compilation to preserve existing CSS sections.
+ */
+
+/**
+ * Extracts a specific section from CSS documentation using regex matching
+ * Looks for content between matching comment markers
+ *
+ * @param {string} section - Name of the section to extract
+ * @param {string} doc - CSS document content to search in
+ * @returns {string} Extracted section content (trimmed) or empty string if not found
+ */
+const extractDocFragment = ({ section, doc }) => {
+  // Create regex pattern to match section markers
+  const matcher = new RegExp(
+    `/\\* ${section} \\*/([\\s\\S]*?)/\\* ${section} \\*/`
+  );
+  const match = doc.match(matcher);
+  return match ? match[1].trim() : '';
+};
+
+module.exports = { extractDocFragment };

package/src/lib/fileExists/fileExists.utils.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Checks if a file exists at the specified path
+ * Safely handles path resolution and filesystem access errors
+ *
+ * @param {string} dir - The base directory path
+ * @param {string} currentPath - The relative file path to check
+ * @returns {boolean} True if the file exists, false otherwise
+ *
+ * @example
+ * fileExists('/project', 'src/index.js') // true if /project/src/index.js exists
+ * fileExists('.', 'package.json') // true if ./package.json exists
+ */
+const fileExists = (dir, currentPath) => {
+  try {
+    if (!dir || !currentPath) {
+      return false;
+    }
+
+    const fullPath = path.resolve(dir, currentPath);
+    return fs.existsSync(fullPath);
+  } catch (error) {
+    // Handle any filesystem or path resolution errors
+    console.warn(`Error checking file existence: ${error.message}`);
+    return false;
+  }
+};
+
+module.exports = { fileExists };

package/src/lib/generateBaseCss/generateBaseCss.utils.js

@@ -0,0 +1,51 @@
+/**
+ * Base CSS Generation for Bernova
+ *
+ * Generates foundational CSS including font definitions and CSS reset.
+ * Handles local font copying and CSS font-face generation.
+ */
+
+const { resetCss: defaultResetCss } = require('../../constants/resetCss');
+const { copyLocalFonts } = require('../copyLocalFonts/copyLocalFonts.utils');
+const {
+  generateCssFonts,
+} = require('../copyLocalFonts/generateCssFonts.utils');
+
+/**
+ * Generates base CSS content including fonts and optional reset styles
+ *
+ * @param {Object} params - Generation parameters
+ * @param {Object} params.fonts - Font configuration object
+ * @param {Array} params.fonts.local - Local font files to copy
+ * @param {boolean} params.resetCss - Whether to include CSS reset
+ * @param {string} params.stylesPath - Output path for font files
+ * @returns {Promise<string>} Generated base CSS content
+ */
+const generateBaseCss = async ({ fonts, resetCss, stylesPath }) => {
+  // Copy local font files to the output directory
+  if (fonts?.local && Array.isArray(fonts.local) && fonts.local.length > 0) {
+    await copyLocalFonts(fonts.local, stylesPath);
+  }
+
+  // Generate base CSS content
+  return (() => {
+    let baseCss = '';
+
+    // Add font-face declarations if fonts are configured
+    if (fonts) {
+      const fontCss = generateCssFonts(fonts);
+      if (fontCss) {
+        baseCss += fontCss + '\n';
+      }
+    }
+
+    // Add CSS reset if enabled
+    if (resetCss) {
+      baseCss += defaultResetCss + '\n';
+    }
+
+    return baseCss;
+  })();
+};
+
+module.exports = { generateBaseCss };

package/src/lib/generateCss/generateCSS.utils.js

@@ -0,0 +1,42 @@
+const { filterGenerateCss } = require('./helpers/filterGenerateCss.utils');
+
+/**
+ * Generates CSS based on the provided source, media queries, and other parameters.
+ *
+ * @param {Object} source - The source object containing foundations and theme.
+ * @param {string} dir - The directory where the CSS files will be saved.
+ * @param {Array} mediaQueries - An array of media queries to be used.
+ * @param {string} name - The name to be used for the generated CSS.
+ * @param {boolean} [generateProvider=false] - Flag to determine if a provider should be generated.
+ * @param {string} [baseCss=''] - Base font CSS to be included in the generated CSS.
+ * @returns {Promise<Object>} - A promise that resolves to an object containing the generated CSS and minified CSS.
+ */
+const generateCSS = async ({ source, prefix, baseCss = '', compilerType }) => {
+  const { default: ora } = await import('ora');
+  const spinner = ora('Generating CSS...').start();
+
+  try {
+    const { stylesCss, foundationsCss, stylesDocs, rootDocs, globalDocs } =
+      filterGenerateCss({
+        source,
+        compilerType,
+        baseCss,
+        prefix,
+      });
+
+    spinner.succeed('CSS generation completed successfully.');
+    return {
+      stylesCss,
+      foundationsCss,
+      stylesDocs,
+      rootDocs,
+      globalDocs,
+    };
+  } catch (error) {
+    spinner.fail('Error generating CSS.');
+    console.error(error);
+    throw error; // Re-throw the error after logging it
+  }
+};
+
+module.exports = { generateCSS };

package/src/lib/generateCss/helpers/advanceselector/advancedSelectorHandler.utils.js

@@ -0,0 +1,22 @@
+const { cssAdvancedSelectors } = require('../../../../constants/index.js');
+
+/**
+ * Handles advanced CSS selectors and processes nested objects.
+ *
+ * @param {Array} selectors - An array of selector objects.
+ * @param {string} ruleName - The base rule name to be used.
+ * @param {Function} processSource - A function to process nested objects.
+ */
+const advancedSelectorHandler = (selectors, ruleName, processSource) => {
+  selectors.forEach((key) => {
+    for (const [selector, { $target, ...value }] of Object.entries(key)) {
+      if (cssAdvancedSelectors[selector] && $target) {
+        const parsedSelector = cssAdvancedSelectors[selector];
+        const completeRuleName = `${ruleName}${parsedSelector}${$target}`;
+        processSource({ source: value, theRule: completeRuleName });
+      }
+    }
+  });
+};
+
+module.exports = { advancedSelectorHandler };