cornet-ui 0.1.0-beta.1

package/plugin-vite.ts

@@ -0,0 +1,286 @@
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, extname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { Plugin, ResolvedConfig } from 'vite'
+
+export interface CornetPluginOptions {
+  /**
+   * Root directory of the Cornet library (the folder containing `index.ts`
+   * and `index.css`). Auto-detected from the plugin location by default,
+   * which works both for npm installs and for the embedded/submodule mode.
+   */
+  libPath?: string
+  /**
+   * Application source directories to scan for component usage,
+   * relative to the Vite project root. Default: `['src']`.
+   */
+  srcDirs?: string[]
+  /**
+   * Import specifiers that resolve to the Cornet library. Defaults to the
+   * `name` field of the library package.json. Add entries here if you import
+   * the library through an alias or a relative path.
+   */
+  packageNames?: string[]
+  /** Print a summary on stdout during build. Default: `true`. */
+  showOutput?: boolean
+  /** Abort the build when detection fails. Default: `false` (fail-safe). */
+  failOnError?: boolean
+}
+
+const SOURCE_EXTENSIONS = ['.vue', '.js', '.ts', '.tsx', '.jsx']
+
+/**
+ * Stable content of `index.css`. The plugin temporarily appends
+ * `@source not` directives to that file during `vite build`, then restores
+ * this exact content so the file never changes from git's point of view.
+ */
+export const CSS_BASE_CONTENT = `/* Cornet CSS entry.
+   During \`vite build\`, the Cornet Vite plugin temporarily appends
+   \`@source not\` directives here to exclude unused components from
+   Tailwind's scanning, then restores this file. Without the plugin,
+   Tailwind simply scans every component: everything still works. */
+`
+
+/** Parse `export { default as X } from './components/...'` lines of index.ts. */
+export function parseLibraryExports(indexContent: string): Map<string, string> {
+  const components = new Map<string, string>()
+  const exportRegex = /export\s*{\s*default\s+as\s+(\w+)\s*}\s+from\s+['"](.+?)['"]/g
+  let match: RegExpExecArray | null
+  while ((match = exportRegex.exec(indexContent)) !== null) {
+    components.set(match[1], match[2])
+  }
+  return components
+}
+
+export interface UsageScanResult {
+  /** Component names found in named imports or as `<DuX>` template tags. */
+  used: Set<string>
+  /** A namespace import (`import * as X from 'cornet-ui'`) was found: assume everything is used. */
+  namespaceImport: boolean
+}
+
+/** Scan one source file's content for Cornet component usage. */
+export function scanSourceContent(content: string, packageNames: string[]): UsageScanResult {
+  const used = new Set<string>()
+  let namespaceImport = false
+
+  for (const pkg of packageNames) {
+    const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const namedImportRegex = new RegExp(`import\\s+{([^}]+)}\\s+from\\s+['"]${escaped}['"]`, 'g')
+    let match: RegExpExecArray | null
+    while ((match = namedImportRegex.exec(content)) !== null) {
+      for (const item of match[1].split(',')) {
+        const name = item.trim().split(/\s+as\s+/)[0].trim()
+        if (name) used.add(name)
+      }
+    }
+    const namespaceRegex = new RegExp(`import\\s+\\*\\s+as\\s+\\w+\\s+from\\s+['"]${escaped}['"]`)
+    if (namespaceRegex.test(content)) namespaceImport = true
+  }
+
+  // Components referenced directly in templates (global registration, auto-import...)
+  const tagRegex = /<(Du\w+)[\s/>]/g
+  let tagMatch: RegExpExecArray | null
+  while ((tagMatch = tagRegex.exec(content)) !== null) {
+    used.add(tagMatch[1])
+  }
+
+  return { used, namespaceImport }
+}
+
+/**
+ * Components may use each other internally (e.g. DuFab renders DuButton).
+ * Expand the used set so a dependency of a used component is never excluded.
+ */
+export function expandWithInternalDependencies(
+  used: Set<string>,
+  componentPaths: Map<string, string>,
+  libRoot: string,
+): Set<string> {
+  // Map absolute .vue file path -> component name
+  const fileToComponent = new Map<string, string>()
+  for (const [name, relPath] of componentPaths) {
+    fileToComponent.set(resolve(libRoot, relPath), name)
+  }
+
+  // Map component name -> internal component dependencies
+  const dependencies = new Map<string, string[]>()
+  const importRegex = /import\s+\w+\s+from\s+['"](\.[^'"]+\.vue)['"]/g
+  for (const [name, relPath] of componentPaths) {
+    const absPath = resolve(libRoot, relPath)
+    if (!existsSync(absPath)) continue
+    const content = readFileSync(absPath, 'utf-8')
+    const deps: string[] = []
+    let match: RegExpExecArray | null
+    while ((match = importRegex.exec(content)) !== null) {
+      const depAbs = resolve(dirname(absPath), match[1])
+      const depName = fileToComponent.get(depAbs)
+      if (depName && depName !== name) deps.push(depName)
+    }
+    if (deps.length) dependencies.set(name, deps)
+  }
+
+  const expanded = new Set(used)
+  const queue = [...used]
+  while (queue.length) {
+    const current = queue.pop()!
+    for (const dep of dependencies.get(current) ?? []) {
+      if (!expanded.has(dep)) {
+        expanded.add(dep)
+        queue.push(dep)
+      }
+    }
+  }
+  return expanded
+}
+
+/** Generate the deterministic `@source not` block for unused components. */
+export function generateExclusionCss(
+  componentPaths: Map<string, string>,
+  used: Set<string>,
+): { css: string; excludedCount: number } {
+  const unused = [...componentPaths.keys()].filter((name) => !used.has(name)).sort()
+  let css = ''
+  for (const name of unused) {
+    const relPath = componentPaths.get(name)!.replace(/^\.\//, '')
+    css += `@source not "./${relPath}";\n`
+  }
+  return { css, excludedCount: unused.length }
+}
+
+function findPackageRoot(startDir: string): string {
+  let dir = startDir
+  for (let i = 0; i < 6; i++) {
+    if (existsSync(join(dir, 'package.json'))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return startDir
+}
+
+function collectSourceFiles(dir: string): string[] {
+  const results: string[] = []
+  if (!existsSync(dir)) return results
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry)
+    const stat = statSync(fullPath)
+    if (stat.isDirectory()) {
+      if (entry !== 'node_modules') results.push(...collectSourceFiles(fullPath))
+    } else if (SOURCE_EXTENSIONS.includes(extname(entry))) {
+      results.push(fullPath)
+    }
+  }
+  return results
+}
+
+/**
+ * Cornet Vite plugin.
+ *
+ * At build time, detects which Cornet components the application actually
+ * uses and excludes the unused ones from Tailwind's source scanning
+ * (`@source not` directives), reducing the generated CSS.
+ *
+ * The plugin is optional and fail-safe: without it (or when detection
+ * fails), Tailwind scans every component and everything still works.
+ */
+export default function cornetPlugin(options: CornetPluginOptions = {}): Plugin {
+  const { showOutput = true, failOnError = false } = options
+
+  let config: ResolvedConfig | undefined
+  let libRoot: string | undefined
+  let cssFilePath: string | undefined
+
+  const fail = (error: unknown) => {
+    console.error('[vite-plugin-cornet] component detection failed:', error)
+    if (failOnError) throw error
+  }
+
+  const restoreCss = () => {
+    try {
+      if (cssFilePath && existsSync(cssFilePath) && readFileSync(cssFilePath, 'utf-8') !== CSS_BASE_CONTENT) {
+        writeFileSync(cssFilePath, CSS_BASE_CONTENT)
+      }
+    } catch (error) {
+      fail(error)
+    }
+  }
+
+  return {
+    name: 'vite-plugin-cornet',
+    apply: 'build',
+
+    configResolved(resolved) {
+      config = resolved
+    },
+
+    buildStart() {
+      try {
+        libRoot = options.libPath
+          ? resolve(options.libPath)
+          : findPackageRoot(dirname(fileURLToPath(import.meta.url)))
+        cssFilePath = join(libRoot, 'index.css')
+
+        const indexPath = join(libRoot, 'index.ts')
+        if (!existsSync(indexPath)) {
+          console.warn(`[vite-plugin-cornet] library index not found at ${indexPath}, skipping detection`)
+          return
+        }
+        const componentPaths = parseLibraryExports(readFileSync(indexPath, 'utf-8'))
+
+        let packageNames = options.packageNames
+        if (!packageNames) {
+          const pkgPath = join(libRoot, 'package.json')
+          const pkgName = existsSync(pkgPath)
+            ? (JSON.parse(readFileSync(pkgPath, 'utf-8')).name as string | undefined)
+            : undefined
+          packageNames = pkgName ? [pkgName] : []
+        }
+
+        const root = config?.root ?? process.cwd()
+        const srcDirs = options.srcDirs ?? ['src']
+
+        const used = new Set<string>()
+        let namespaceImport = false
+        for (const srcDir of srcDirs) {
+          for (const file of collectSourceFiles(resolve(root, srcDir))) {
+            const result = scanSourceContent(readFileSync(file, 'utf-8'), packageNames)
+            result.used.forEach((name) => used.add(name))
+            namespaceImport ||= result.namespaceImport
+          }
+        }
+
+        if (namespaceImport) {
+          if (showOutput) {
+            console.log('[vite-plugin-cornet] namespace import detected, keeping all components')
+          }
+          restoreCss()
+          return
+        }
+
+        const expanded = expandWithInternalDependencies(used, componentPaths, libRoot)
+        const { css, excludedCount } = generateExclusionCss(componentPaths, expanded)
+        writeFileSync(cssFilePath, CSS_BASE_CONTENT + css)
+
+        if (showOutput) {
+          console.log(
+            `[vite-plugin-cornet] ${expanded.size}/${componentPaths.size} components used, ${excludedCount} excluded from CSS`,
+          )
+        }
+      } catch (error) {
+        fail(error)
+      }
+    },
+
+    // Restore the committed content so index.css never appears modified in git.
+    closeBundle: restoreCss,
+    buildEnd(error) {
+      if (error) restoreCss()
+    },
+  }
+}
+
+export { cornetPlugin }
+
+/** @deprecated Use `cornetPlugin` (default export) instead. */
+export const vueDaisyUI = cornetPlugin

package/types/index.ts

@@ -0,0 +1,59 @@
+/**
+ * Types and Interfaces exports for cornet-ui
+ * Auto-generated file - do not edit manually
+ */
+
+export type { BUTTONSize,BUTTONColor } from '../components/Actions/du-button/du-button.types'
+export type { DROPDOWNPlacement,PlacementValue,PlacementInput } from '../components/Actions/du-dropdown/du-dropdown.types'
+export type { FABModifier,FABItem,FABMainAction,FABCloseButton } from '../components/Actions/du-fab/du-fab.types'
+export type { MODALPlacement } from '../components/Actions/du-modal/du-modal.types'
+export type { SWAPProperty } from '../components/Actions/du-swap/du-swap.types'
+export type { ACCORDIONModifier,ACCORDIONItem } from '../components/DataDisplay/du-accordion/du-accordion.types'
+export type { Rounded,Mask,AVATARSize,AVATARRounded,AVATARRingColor,AVATARColor,AVATARMask } from '../components/DataDisplay/du-avatar/du-avatar.types'
+export type { BADGESize,BADGEVariant } from '../components/DataDisplay/du-badge/du-badge.types'
+export type { CARDSize,CARDProperty } from '../components/DataDisplay/du-card/du-card.types'
+export type { CAROUSELPosition,CarouselItem } from '../components/DataDisplay/du-carousel/du-carousel.types'
+export type { CHATColor,ChatPlacement,ChatItem,ChatProps } from '../components/DataDisplay/du-chat/du-chat.types'
+export type { COLLAPSEModifier,COLLAPSEItem } from '../components/DataDisplay/du-collapse/du-collapse.types'
+export type { COUNTDOWNFormat,COUNTDOWNLabels } from '../components/DataDisplay/du-countdown/du-countdown.types'
+export type { DIFFAspectRatio } from '../components/DataDisplay/du-diff/du-diff.types'
+export type { KBDSize } from '../components/DataDisplay/du-kbd/du-kbd.types'
+export type { LISTProps } from '../components/DataDisplay/du-list/du-list.types'
+export type { STATItem } from '../components/DataDisplay/du-stat/du-stat.types'
+export type { STATSItem } from '../components/DataDisplay/du-stats/du-stats.types'
+export type { STATUSSize,STATUSVariant } from '../components/DataDisplay/du-status/du-status.types'
+export type { TABLEItemProps } from '../components/DataDisplay/du-table/du-table-item.types'
+export type { TABLESize,TABLEColumn,TABLERow,TABLEProps } from '../components/DataDisplay/du-table/du-table.types'
+export type { TIMELINEDirection,TIMELINEModifier,TIMELINEItem } from '../components/DataDisplay/du-timeline/du-timeline.types'
+export type { CHECKBOXVariant,CHECKBOXSize,CHECKBOXProps } from '../components/DataInput/du-checkbox/du-checkbox.types'
+export type { FIELDSETProps } from '../components/DataInput/du-fieldset/du-fieldset.types'
+export type { FILEINPUTProps } from '../components/DataInput/du-file-input/du-file-input.types'
+export type { FilterButtonArgs,FilterItem,FilterProps } from '../components/DataInput/du-filter/du-filter.types'
+export type { INPUTFIELDVariant,INPUTFIELDSize,INPUTFIELDType,INPUTFIELDValidatorProps,INPUTFIELDProps } from '../components/DataInput/du-input-field/du-input-field.types'
+export type { LabelInputValidatorProps } from '../components/DataInput/du-label-input-validator/du-label-input-validator.types'
+export type { LABELProps } from '../components/DataInput/du-label/du-label.types'
+export type { RADIOVariant,RADIOSize,RADIOProps } from '../components/DataInput/du-radio/du-radio.types'
+export type { RANGEVariant,RANGESize,RANGEProps } from '../components/DataInput/du-range/du-range.types'
+export type { RatingSize,RatingShape,RatingItem,RatingProps,RatingItemProps,RatingEmits,RatingItemEmits } from '../components/DataInput/du-rating/du-rating.types'
+export type { SEARCHVariant,SEARCHSize,SearchOption,SEARCHProps } from '../components/DataInput/du-search/du-search.types'
+export type { SELECTVariant,SELECTSize,SELECTProps } from '../components/DataInput/du-select/du-select.types'
+export type { TEXTAREAProps } from '../components/DataInput/du-text-area/du-text-area.types'
+export type { AlertVariant,AlertDirection,AlertProps } from '../components/Feedback/du-alert/du-alert.types'
+export type { LoadingAnimation,LoadingProps } from '../components/Feedback/du-loading/du-loading.types'
+export type { ProgressProps } from '../components/Feedback/du-progress/du-progress.types'
+export type { RadialProgressProps } from '../components/Feedback/du-radial-progress/du-radial-progress.types'
+export type { SkeletonProps } from '../components/Feedback/du-skeleton/du-skeleton.types'
+export type { ToastHorizontalPosition,ToastVerticalPosition,ToastProps } from '../components/Feedback/du-toast/du-toast.types'
+export type { TooltipPosition,TooltipProps } from '../components/Feedback/du-tooltip/du-tooltip.types'
+export type { DRAWERPosition,DRAWERItem,DRAWERProps } from '../components/Layout/du-drawer/du-drawer.types'
+export type { JoinDirection,JoinProps } from '../components/Layout/du-join/du-join.types'
+export type { BreadcrumbItem,BreadcrumbsProps } from '../components/Navigation/du-breadcrumbs/du-breadcrumbs.types'
+export type { ButtonLinkProps } from '../components/Navigation/du-button-link/du-button-link.types'
+export type { DOCKSize,DockItem,DockProps } from '../components/Navigation/du-dock/du-dock.types'
+export type { LinkProps } from '../components/Navigation/du-link/du-link.types'
+export type { MenuDirection,MENUSize,MenuItem,MenuProps } from '../components/Navigation/du-menu/du-menu.types'
+export type { NavbarProps } from '../components/Navigation/du-navbar/du-navbar.types'
+export type { PaginationProps } from '../components/Navigation/du-pagination/du-pagination.types'
+export type { StepItemProps } from '../components/Navigation/du-step-item/du-step-item.types'
+export type { StepsDirection,StepItem,StepsProps } from '../components/Navigation/du-steps/du-steps.types'
+export type { TabsType,TabItem,TabsProps } from '../components/Navigation/du-tabs/du-tabs.types'

package/types/types.sh

@@ -0,0 +1,80 @@
+#!/bin/bash
+
+BASE_DIR="../components"
+OUTPUT_FILE="./index.ts"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+PURPLE='\033[0;35m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}🚀 Génération du fichier index.ts avec les types exportés...${NC}"
+echo
+
+cat > "$OUTPUT_FILE" << 'EOF'
+/**
+ * Types and Interfaces exports for cornet-ui
+ * Auto-generated file - do not edit manually
+ */
+
+EOF
+
+extract_and_write_types() {
+    local file=$1
+    local relative_path=${file#$BASE_DIR/}
+    local import_path="../components/${relative_path%.ts}"
+    
+    types=$(grep -oP 'export type \K[A-Za-z_][A-Za-z0-9_]*(?=\s*=)' "$file" 2>/dev/null)
+
+    interfaces=$(grep -oP 'export interface \K[A-Za-z_][A-Za-z0-9_]*' "$file" 2>/dev/null)
+    
+    all_exports=""
+    
+    if [ -n "$types" ]; then
+        all_exports="$types"
+    fi
+    
+    if [ -n "$interfaces" ]; then
+        if [ -n "$all_exports" ]; then
+            all_exports="$all_exports
+$interfaces"
+        else
+            all_exports="$interfaces"
+        fi
+    fi
+    
+    if [ -n "$all_exports" ]; then
+        echo -e "${GREEN}📁 $relative_path${NC}"
+        
+        exports_list=$(echo "$all_exports" | tr '\n' ',' | sed 's/,$//' | sed 's/,,/,/g')
+        
+        echo "export type { $exports_list } from '$import_path'" >> "$OUTPUT_FILE"
+        
+        if [ -n "$types" ]; then
+            echo -e "  ${YELLOW}Types:${NC}"
+            while IFS= read -r type; do
+                echo -e "    → $type"
+            done <<< "$types"
+        fi
+        
+        if [ -n "$interfaces" ]; then
+            echo -e "  ${PURPLE}Interfaces:${NC}"
+            while IFS= read -r interface; do
+                echo -e "    → $interface"
+            done <<< "$interfaces"
+        fi
+        
+        echo
+    fi
+}
+
+# LC_ALL=C makes the sort order byte-based and locale-independent,
+# so the generated file is identical on every machine (CI drift guard).
+find "$BASE_DIR" -name "*.types.ts" -type f | LC_ALL=C sort | while read -r file; do
+    extract_and_write_types "$file"
+done
+
+echo -e "${GREEN}✅ Fichier généré: $OUTPUT_FILE${NC}"
+echo