@pixelated-tech/components 3.7.0 → 3.7.1

package/dist/scripts/generate-site-images.js

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+const fs = require('fs');
+const path = require('path');
+
+const publicDir = path.join(__dirname, '..', 'public');
+const outFile = path.join(publicDir, 'site-images.json');
+
+function listFiles(dir, exts = ['.jpg','.jpeg','.png','.webp','.avif','.gif']) {
+	const out = [];
+	if (!fs.existsSync(dir)) return out;
+	const items = fs.readdirSync(dir, { withFileTypes: true });
+	for (const it of items) {
+		const full = path.join(dir, it.name);
+		if (it.isDirectory()) out.push(...listFiles(full, exts));
+		else if (exts.includes(path.extname(it.name).toLowerCase())) {
+			out.push(path.relative(publicDir, full).replace(/\\\\/g, '/'));
+		}
+	}
+	return out;
+}
+
+const files = listFiles(publicDir);
+const manifest = {
+	metadata: {
+		generatedAt: new Date().toISOString(),
+		imageCount: files.length,
+	},
+	images: files,
+};
+fs.writeFileSync(outFile, JSON.stringify(manifest, null, 2), 'utf8');
+console.log('Wrote', outFile, 'with', files.length, 'images and metadata');

package/dist/scripts/proptypes-inferprops.js

@@ -0,0 +1,205 @@
+import { isClientComponent } from '../components/utilities/functions.ts';
+
+export default {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce PropTypes + InferProps pattern for React components',
+			category: 'Best Practices',
+			recommended: true,
+		},
+		fixable: false,
+		schema: [],
+		messages: {
+			missingPropTypes: 'Component "{{componentName}}" is missing propTypes. Add: {{componentName}}.propTypes = { ... }; immediately above the function.',
+			missingInferProps: 'Component "{{componentName}}" is missing InferProps type. Add: export type {{componentName}}Type = InferProps<typeof {{componentName}}.propTypes>; immediately above the function.',
+			invalidInferProps: 'InferProps type for "{{componentName}}" must be named "{{componentName}}Type" and exported. Rename and add export.',
+			missingInferPropsUsage: 'Component "{{componentName}}" function parameters must use the InferProps type. Change: export function {{componentName}}(props: {{componentName}}Type)',
+			propTypesPlacement: 'Component "{{componentName}}" propTypes must be defined immediately above the function declaration with no blank lines. Move {{componentName}}.propTypes = { ... }; right above the function.',
+			inferPropsPlacement: 'Component "{{componentName}}" InferProps type must be defined immediately above the function declaration with no blank lines. Move export type {{componentName}}Type = ...; right above the function.',
+		},
+	},
+	create(context) {
+
+		const components = new Map(); // Track components and their patterns
+
+		function checkForInferProps(typeAnnotation) {
+			if (!typeAnnotation) return false;
+      
+			if (typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName?.name === 'InferProps') {
+				return true;
+			}
+      
+			if (typeAnnotation.type === 'TSIntersectionType') {
+				return typeAnnotation.types.some(checkForInferProps);
+			}
+      
+			return false;
+		}
+
+		function extractComponentNameFromInferProps(node) {
+			// For our pattern of ComponentType = InferProps<typeof Component.propTypes>
+			// We can simply remove 'Type' from the type name
+			return node.id.name.replace('Type', '');
+		}
+
+		function reportViolations(component) {
+			const { functionNode, hasPropTypes, hasInferProps, usesInferProps, inferPropsName, propTypesNode, inferPropsNode } = component;
+			if (!functionNode) return; // Skip if function not found yet
+      
+			const componentName = functionNode.id.name;
+
+			if (!hasPropTypes) {
+				context.report({
+					node: functionNode,
+					messageId: 'missingPropTypes',
+					data: { componentName },
+				});
+			}
+
+			if (!hasInferProps) {
+				context.report({
+					node: functionNode,
+					messageId: 'missingInferProps',
+					data: { componentName },
+				});
+			}
+
+			if (hasPropTypes && hasInferProps && !usesInferProps && functionNode.params.length > 0) {
+				context.report({
+					node: functionNode,
+					messageId: 'missingInferPropsUsage',
+					data: { componentName, inferPropsName },
+				});
+			}
+
+			// Check placement and ordering: propTypes -> InferProps -> function (consecutive, no empty lines)
+			if (hasPropTypes && hasInferProps && propTypesNode && inferPropsNode) {
+				const propTypesEndLine = propTypesNode.loc.end.line;
+				const inferPropsLine = inferPropsNode.loc.start.line;
+				const functionLine = functionNode.loc.start.line;
+        
+				// InferProps must immediately follow propTypes (no empty lines)
+				if (inferPropsLine !== propTypesEndLine + 1) {
+					context.report({
+						node: inferPropsNode,
+						messageId: 'inferPropsPlacement',
+						data: { componentName },
+					});
+				}
+        
+				// Function must immediately follow InferProps (no empty lines)
+				if (functionLine !== inferPropsLine + 1) {
+					context.report({
+						node: functionNode,
+						messageId: 'propTypesPlacement',
+						data: { componentName },
+					});
+				}
+			}
+		}
+
+		return {
+			// Find component function declarations
+			FunctionDeclaration(node) {
+				if (node.id && node.id.name && node.parent.type === 'ExportNamedDeclaration') {
+					const componentName = node.id.name;
+
+					// Check if this is a client component (contains client-only patterns)
+					const sourceCode = context.getSourceCode();
+					const fileContent = sourceCode.text;
+					if (componentName[0] === componentName[0].toUpperCase() && isClientComponent(fileContent)) {
+						if (!components.has(componentName)) {
+							components.set(componentName, {
+								functionNode: node,
+								hasPropTypes: false,
+								hasInferProps: false,
+								inferPropsName: `${componentName}Type`,
+								usesInferProps: false,
+								propTypesNode: null,
+								inferPropsNode: null,
+							});
+						} else {
+							// Component entry already exists (e.g., from propTypes), just update functionNode
+							components.get(componentName).functionNode = node;
+						}
+					}
+				}
+			},
+
+			// Find PropTypes assignments
+			AssignmentExpression(node) {
+				if (
+					node.left.type === 'MemberExpression' &&
+          node.left.object.type === 'Identifier' &&
+          node.left.property.name === 'propTypes'
+				) {
+					const componentName = node.left.object.name;
+					if (!components.has(componentName)) {
+						// Component might be declared later, create entry now
+						components.set(componentName, {
+							functionNode: null, // Will be set when function is found
+							hasPropTypes: false,
+							hasInferProps: false,
+							inferPropsName: `${componentName}Type`,
+							usesInferProps: false,
+							propTypesNode: null,
+							inferPropsNode: null,
+						});
+					}
+					const component = components.get(componentName);
+					component.hasPropTypes = true;
+					component.propTypesNode = node;
+				}
+			},
+
+			// Find InferProps type declarations
+			TSTypeAliasDeclaration(node) {
+				if (node.parent.type === 'ExportNamedDeclaration') {
+					const componentName = extractComponentNameFromInferProps(node);
+					if (componentName && components.has(componentName)) {
+						const component = components.get(componentName);
+						if (node.id.name === component.inferPropsName) {
+							// Check if type annotation contains InferProps
+							const hasInferProps = checkForInferProps(node.typeAnnotation);
+							if (hasInferProps) {
+								component.hasInferProps = true;
+								component.inferPropsNode = node;
+							}
+						}
+					}
+				}
+			},
+
+			// Check function parameters
+			'FunctionDeclaration:exit'(node) {
+				if (node.id && components.has(node.id.name)) {
+					const component = components.get(node.id.name);
+
+					// Check if function uses the InferProps type
+					if (node.params.length === 1) {
+						const param = node.params[0];
+            
+						// Handle both direct type annotation and destructured parameters
+						let paramTypeName = null;
+            
+						if (param.type === 'Identifier' && param.typeAnnotation?.typeAnnotation?.type === 'TSTypeReference') {
+							// Direct parameter: (props: ComponentType)
+							paramTypeName = param.typeAnnotation.typeAnnotation.typeName?.name;
+						} else if (param.type === 'ObjectPattern' && param.typeAnnotation?.typeAnnotation?.type === 'TSTypeReference') {
+							// Destructured parameter: ({ prop }: ComponentType)
+							paramTypeName = param.typeAnnotation.typeAnnotation.typeName?.name;
+						}
+            
+						if (paramTypeName === component.inferPropsName) {
+							component.usesInferProps = true;
+						}
+					}
+
+					// Report violations
+					reportViolations(component);
+				}
+			},
+		};
+	},
+};

package/dist/scripts/release.sh

@@ -0,0 +1,194 @@
+#!/bin/bash
+
+# Universal Release Script for Pixelated Projects
+# This script builds in dev, updates main, and optionally publishes to npm
+
+set -e  # Exit on any error
+
+# Get project name from package.json
+PROJECT_NAME=$(node -p "require('./package.json').name" 2>/dev/null || echo "unknown-project")
+
+# Function to prompt for remote selection
+prompt_remote_selection() {
+    echo "Available git remotes:" >&2
+    local remotes=($(git remote))
+    local i=1
+    for remote in "${remotes[@]}"; do
+        echo "$i) $remote" >&2
+        ((i++))
+    done
+    
+    local choice
+    read -p "Select remote to use (1-${#remotes[@]}): " choice >&2
+    
+    case $choice in
+        [1-9]|[1-9][0-9])
+            if [ "$choice" -le "${#remotes[@]}" ]; then
+                echo "${remotes[$((choice-1))]}"
+            else
+                echo "${remotes[0]}"  # Default to first if invalid
+            fi
+            ;;
+        *) echo "${remotes[0]}" ;;  # Default to first remote
+    esac
+}
+
+# Select remote
+REMOTE_NAME=$(prompt_remote_selection)
+
+echo "🚀 Starting Release Process for $PROJECT_NAME"
+echo "================================================="
+
+# Function to get current version
+get_current_version() {
+    node -p "require('./package.json').version"
+}
+
+# Function to prompt for version bump type
+prompt_version_type() {
+    echo "Current version: $(get_current_version)" >&2
+    echo "Select version bump type:" >&2
+    echo "1) patch (x.x.1)" >&2
+    echo "2) minor (x.1.0)" >&2
+    echo "3) major (1.x.x)" >&2
+    echo "4) custom version" >&2
+    echo "5) no version bump" >&2
+    read -p "Enter choice (1-5): " choice >&2
+    case $choice in
+        1) version_type="patch" ;;
+        2) version_type="minor" ;;
+        3) version_type="major" ;;
+        4)
+            read -p "Enter custom version: " custom_version >&2
+            version_type="$custom_version"
+            ;;
+        5) version_type="none" ;;
+        *) version_type="patch" ;; # default
+    esac
+}
+
+# Function to prompt for commit message
+prompt_commit_message() {
+    read -p "Enter commit message (or press enter for default): " commit_msg
+    if [ -z "$commit_msg" ]; then
+        echo "chore: release $(get_current_version)"
+    else
+        echo "$commit_msg"
+    fi
+}
+
+# Function to prompt for publishing
+prompt_publish() {
+    read -p "Do you want to publish to npm? (y/n): " should_publish
+    if [ "$should_publish" = "y" ] || [ "$should_publish" = "Y" ]; then
+        echo "yes"
+    else
+        echo "no"
+    fi
+}
+
+# Function to prompt for OTP
+prompt_otp() {
+    read -p "Enter npm OTP: " otp
+    echo "$otp"
+}
+
+# Check if we're on dev branch
+current_branch=$(git branch --show-current)
+if [ "$current_branch" != "dev" ]; then
+    echo "❌ Error: Must be on dev branch to run this script"
+    echo "Current branch: $current_branch"
+    echo "Please switch to dev branch: git checkout dev"
+    exit 1
+fi
+
+echo "📦 Step 1: Updating dependencies..."
+npm outdated | awk 'NR>1 {print $1"@"$4}' | xargs npm install --force --save 2>/dev/null || true
+npm audit fix --force 2>/dev/null || true
+
+echo "🔍 Step 2: Running lint..."
+npm run lint
+
+echo "🔨 Step 3: Building project..."
+npm run build
+
+echo "🏷️  Step 4: Version bump..."
+prompt_version_type
+if [ "$version_type" != "none" ]; then
+    if [ "$version_type" = "patch" ] || [ "$version_type" = "minor" ] || [ "$version_type" = "major" ]; then
+        npm version $version_type --force --no-git-tag-version
+    else
+        # Custom version
+        npm version $version_type --force --no-git-tag-version
+    fi
+fi
+
+echo "💾 Step 5: Committing changes..."
+commit_message=$(prompt_commit_message)
+git add . -v
+if git diff --cached --quiet; then
+    echo "ℹ️  No changes to commit"
+else
+    git commit -m "$commit_message"
+fi
+
+echo "📤 Step 6: Pushing dev branch..."
+# Try to push, if it fails due to remote changes, fetch and rebase
+if ! git push $REMOTE_NAME dev; then
+    echo "⚠️  Push failed, fetching remote changes and rebasing..."
+    git fetch $REMOTE_NAME
+    if git rebase $REMOTE_NAME/dev; then
+        echo "✅ Rebased successfully, pushing..."
+        git push $REMOTE_NAME dev || {
+            echo "❌ Failed to push after rebase. Please check git status."
+            exit 1
+        }
+    else
+        echo "❌ Rebase failed. Please resolve conflicts and run 'git rebase --continue' or 'git rebase --abort'"
+        exit 1
+    fi
+fi
+
+echo "🔄 Step 7: Updating main branch..."
+# Force main to match dev exactly
+git push $REMOTE_NAME dev:main --force
+
+# Also update main locally if it exists
+if git show-ref --verify --quiet refs/heads/main; then
+    git branch -D main 2>/dev/null || true
+    git checkout -b main
+    git reset --hard dev
+    git push $REMOTE_NAME main --force
+    git checkout dev
+fi
+
+echo "🏷️  Step 8: Creating and pushing git tag..."
+new_version=$(get_current_version)
+if ! git tag -l | grep -q "v$new_version"; then
+    git tag "v$new_version"
+    git push $REMOTE_NAME "v$new_version"
+else
+    echo "ℹ️  Tag v$new_version already exists"
+fi
+
+echo "🔐 Step 9: Publishing to npm..."
+should_publish=$(prompt_publish)
+if [ "$should_publish" = "yes" ]; then
+    npm login
+    otp=$(prompt_otp)
+    npm publish --access public --otp=$otp
+    echo "✅ Successfully published to npm!"
+else
+    echo "ℹ️  Skipping npm publish"
+    echo "You can publish manually with: npm publish --access public"
+fi
+
+echo ""
+echo "✅ Release complete!"
+echo "📦 Version: $(get_current_version)"
+echo "📋 Branches updated: dev, main"
+echo "🏷️  Tag created: v$(get_current_version)"
+
+if [ "$should_publish" = "yes" ]; then
+    echo "🔗 https://www.npmjs.com/package/$PROJECT_NAME"
+fi

package/dist/scripts/validate-exports.js

@@ -0,0 +1,280 @@
+import fs from 'fs';
+import glob from 'glob';
+import { CLIENT_ONLY_PATTERNS, TS_FILE_IGNORE_PATTERNS, TSX_FILE_IGNORE_PATTERNS, SERVER_ONLY_PATTERNS } from '../components/utilities/functions.ts';
+
+console.log('🔍 Validating exports...\n');
+
+// Find all .ts files (excluding .d.ts, test files, stories, examples, types.ts)
+const tsFiles = glob.sync('src/components/**/*.ts', {
+	ignore: TS_FILE_IGNORE_PATTERNS
+});
+
+// Find all .tsx files (excluding test files, stories, examples)
+const tsxFiles = glob.sync('src/components/**/*.tsx', {
+	ignore: TSX_FILE_IGNORE_PATTERNS
+});
+
+// Combine all component files
+const allComponentFiles = [...tsFiles, ...tsxFiles];
+
+// Analyze each component file to determine if it's client-required or server-safe
+function analyzeComponentFile(filePath) {
+	const content = fs.readFileSync(filePath, 'utf8');
+
+	// Server-only patterns that indicate this should only be on server (not client)
+	// (Imported from shared utilities)
+
+	// Client-only patterns that require the component to run on client
+	// (Imported from shared utilities)
+
+	// Check if file contains any server-only patterns
+	const isServerOnly = SERVER_ONLY_PATTERNS.some(pattern => pattern.test(content));
+
+	// Check if file contains any client-only patterns
+	const isClientOnly = CLIENT_ONLY_PATTERNS.some(pattern => pattern.test(content));
+
+	return {
+		filePath,
+		isClientOnly,
+		isServerOnly,
+		exportPath: filePath.replace('src/', './').replace(/\.tsx?$/, '')
+	};
+}
+
+// Analyze all component files
+const analyzedComponents = allComponentFiles.map(analyzeComponentFile);
+
+// Special handling for utilities/functions.ts - it's safe for both client and server despite containing pattern definitions
+analyzedComponents.forEach(comp => {
+	if (comp.exportPath === './components/utilities/functions') {
+		comp.isClientOnly = false;
+		comp.isServerOnly = false;
+	}
+});
+
+// Separate admin and non-admin components
+const adminComponents = analyzedComponents.filter(comp => comp.exportPath.startsWith('./components/admin/'));
+const nonAdminComponents = analyzedComponents.filter(comp => !comp.exportPath.startsWith('./components/admin/'));
+
+// Create arrays of components for each bundle (non-admin only)
+// If a component has server-only patterns, it's server-only; if client-only and not server-only, client-only; else safe
+const serverOnlyComponents = nonAdminComponents.filter(comp => comp.isServerOnly);
+const clientOnlyComponents = nonAdminComponents.filter(comp => comp.isClientOnly && !comp.isServerOnly);
+const clientAndServerSafeComponents = nonAdminComponents.filter(comp => !comp.isClientOnly && !comp.isServerOnly);
+
+// Read index files
+const indexServer = fs.readFileSync('src/index.server.js', 'utf8');
+const indexClient = fs.readFileSync('src/index.js', 'utf8');
+const indexAdminServer = fs.readFileSync('src/index.adminserver.js', 'utf8');
+const indexAdminClient = fs.readFileSync('src/index.adminclient.js', 'utf8');
+
+// Helper function to extract exports from index file
+function extractExports(content) {
+	// Remove comments
+	content = content.replace(/\/\*[\s\S]*?\*\//g, '');
+	content = content.replace(/\/\/.*$/gm, '');
+
+	const exports = [];
+
+	// Handle export * from './path' syntax
+	const exportAllRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+	let match;
+
+	while ((match = exportAllRegex.exec(content)) !== null) {
+		exports.push(match[1]);
+	}
+
+	// Handle export { ... } from './path' syntax
+	const exportRegex = /export\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"]/g;
+	while ((match = exportRegex.exec(content)) !== null) {
+		const exportList = match[1];
+		const exportItems = exportList.split(',').map(item => item.trim());
+		exports.push(...exportItems.map(item => match[2])); // Use the from path
+	}
+
+	return exports;
+}
+
+// Extract exports from all index files
+const serverExports = extractExports(indexServer);
+const clientExports = extractExports(indexClient);
+const adminServerExports = extractExports(indexAdminServer);
+const adminClientExports = extractExports(indexAdminClient);
+
+const missing = {
+	server: [],
+	client: [],
+	adminServer: [],
+	adminClient: [],
+	files: [] // New: exported paths that don't correspond to existing files
+};
+
+const bundleErrors = {
+	server: [], // Client-only components incorrectly in server bundle
+	client: [], // Server-only components incorrectly in client bundle
+	adminServer: [], // Client-only components incorrectly in admin server bundle
+	adminClient: [] // Server-only components incorrectly in admin client bundle
+};
+
+// Check if exported paths correspond to existing files
+function checkExportPathsExist(exports, bundleName) {
+	exports.forEach(exportPath => {
+		// Convert export path to file path (./components/... -> src/components/...)
+		const filePathBase = exportPath.replace('./', 'src/');
+		const tsFile = `${filePathBase}.ts`;
+		const tsxFile = `${filePathBase}.tsx`;
+    
+		const tsExists = fs.existsSync(tsFile);
+		const tsxExists = fs.existsSync(tsxFile);
+    
+		if (!tsExists && !tsxExists) {
+			missing.files.push(`${bundleName}: ${exportPath} (.ts/.tsx files not found)`);
+		}
+	});
+}
+
+checkExportPathsExist(serverExports, 'server bundle');
+checkExportPathsExist(clientExports, 'client bundle');
+checkExportPathsExist(adminServerExports, 'admin server bundle');
+checkExportPathsExist(adminClientExports, 'admin client bundle');
+
+// Check for missing exports
+clientAndServerSafeComponents.forEach(comp => {
+	if (!serverExports.includes(comp.exportPath)) {
+		missing.server.push(comp.exportPath);
+	}
+});
+
+serverOnlyComponents.forEach(comp => {
+	if (!serverExports.includes(comp.exportPath)) {
+		missing.server.push(comp.exportPath);
+	}
+});
+
+clientOnlyComponents.forEach(comp => {
+	if (!clientExports.includes(comp.exportPath)) {
+		missing.client.push(comp.exportPath);
+	}
+});
+
+clientAndServerSafeComponents.forEach(comp => {
+	if (!clientExports.includes(comp.exportPath)) {
+		missing.client.push(comp.exportPath);
+	}
+});
+
+// Check admin components - separate server and client bundles
+const serverRelevantAdmin = adminComponents.filter(comp => comp.isServerOnly || !comp.isClientOnly);
+const clientRelevantAdmin = adminComponents.filter(comp => comp.isClientOnly || !comp.isServerOnly);
+
+serverRelevantAdmin.forEach(comp => {
+	if (!adminServerExports.includes(comp.exportPath)) {
+		missing.adminServer.push(comp.exportPath);
+	}
+	if (serverExports.includes(comp.exportPath) && !comp.isServerOnly) {
+		bundleErrors.server.push(comp.exportPath + ' (admin component in server bundle)');
+	}
+	if (clientExports.includes(comp.exportPath) && !comp.isServerOnly) {
+		bundleErrors.client.push(comp.exportPath + ' (admin component in client bundle)');
+	}
+});
+
+clientRelevantAdmin.forEach(comp => {
+	if (!adminClientExports.includes(comp.exportPath)) {
+		missing.adminClient.push(comp.exportPath);
+	}
+	if (serverExports.includes(comp.exportPath) && comp.isClientOnly) {
+		bundleErrors.server.push(comp.exportPath + ' (client-only admin component in server bundle)');
+	}
+	// Allow client-only components in adminserver if they are also server-only (both)
+	if (adminServerExports.includes(comp.exportPath) && comp.isClientOnly && !comp.isServerOnly) {
+		bundleErrors.adminServer.push(comp.exportPath + ' (client-only admin component in admin server bundle)');
+	}
+});
+
+// Check for bundle contamination errors
+clientOnlyComponents.forEach(comp => {
+	if (serverExports.includes(comp.exportPath)) {
+		bundleErrors.server.push(comp.exportPath);
+	}
+});
+
+serverOnlyComponents.forEach(comp => {
+	if (clientExports.includes(comp.exportPath)) {
+		bundleErrors.client.push(comp.exportPath + ' (server-only component in client bundle)');
+	}
+});
+
+// Report results
+console.log('📊 Analysis Results:');
+console.log(`   Found ${allComponentFiles.length} component files`);
+console.log(`   ${clientOnlyComponents.length} client-only components`);
+console.log(`   ${clientAndServerSafeComponents.length} client-and-server-safe components`);
+console.log(`   ${serverOnlyComponents.length} server-only components`);
+console.log(`   ${adminComponents.length} admin components`);
+if (missing.server.length > 0) {
+	console.log('❌ Missing from server bundle (index.server.js):');
+	missing.server.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (missing.client.length > 0) {
+	console.log('❌ Missing from client bundle (index.js):');
+	missing.client.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (missing.adminServer.length > 0) {
+	console.log('❌ Missing from admin server bundle (index.adminserver.js):');
+	missing.adminServer.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (missing.adminClient.length > 0) {
+	console.log('❌ Missing from admin client bundle (index.adminclient.js):');
+	missing.adminClient.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (bundleErrors.server.length > 0) {
+	console.log('🚨 Bundle contamination errors:');
+	console.log('   Client-required components incorrectly exported from server bundle:');
+	bundleErrors.server.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (bundleErrors.client.length > 0) {
+	console.log('🚨 Bundle contamination errors:');
+	console.log('   Server-required components incorrectly exported from client bundle:');
+	bundleErrors.client.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (bundleErrors.adminServer.length > 0) {
+	console.log('🚨 Bundle contamination errors:');
+	console.log('   Client-required components incorrectly exported from admin server bundle:');
+	bundleErrors.adminServer.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (bundleErrors.adminClient.length > 0) {
+	console.log('🚨 Bundle contamination errors:');
+	console.log('   Server-only components incorrectly exported from admin client bundle:');
+	bundleErrors.adminClient.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+if (missing.files.length > 0) {
+	console.log('❌ Exported paths that don\'t exist:');
+	missing.files.forEach(path => console.log(`   - ${path}`));
+	console.log('');
+}
+
+const hasErrors = missing.server.length > 0 || missing.client.length > 0 || missing.adminServer.length > 0 || missing.adminClient.length > 0 || bundleErrors.server.length > 0 || bundleErrors.client.length > 0 || bundleErrors.adminServer.length > 0 || bundleErrors.adminClient.length > 0 || missing.files.length > 0;
+
+if (hasErrors) {
+	console.log('❌ Validation failed!');
+	process.exit(1);
+} else {
+	console.log('✅ All exports validated successfully!');
+}

package/dist/types/scripts/generate-site-images.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-site-images.d.ts.map

package/dist/types/scripts/generate-site-images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-site-images.d.ts","sourceRoot":"","sources":["../../../src/scripts/generate-site-images.js"],"names":[],"mappings":""}

package/dist/types/scripts/proptypes-inferprops.d.ts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    namespace meta {
+        let type: string;
+        namespace docs {
+            let description: string;
+            let category: string;
+            let recommended: boolean;
+        }
+        let fixable: boolean;
+        let schema: never[];
+        namespace messages {
+            let missingPropTypes: string;
+            let missingInferProps: string;
+            let invalidInferProps: string;
+            let missingInferPropsUsage: string;
+            let propTypesPlacement: string;
+            let inferPropsPlacement: string;
+        }
+    }
+    function create(context: any): {
+        FunctionDeclaration(node: any): void;
+        AssignmentExpression(node: any): void;
+        TSTypeAliasDeclaration(node: any): void;
+        'FunctionDeclaration:exit'(node: any): void;
+    };
+}
+export default _default;
+//# sourceMappingURL=proptypes-inferprops.d.ts.map

package/dist/types/scripts/proptypes-inferprops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proptypes-inferprops.d.ts","sourceRoot":"","sources":["../../../src/scripts/proptypes-inferprops.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;IAqBC;;;;;MAsLC"}

package/dist/types/scripts/validate-exports.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate-exports.d.ts.map

package/dist/types/scripts/validate-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-exports.d.ts","sourceRoot":"","sources":["../../../src/scripts/validate-exports.js"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pixelated-tech/components",
-	"version": "3.7.0",
+	"version": "3.7.1",
 	"private": false,
 	"author": {
 		"name": "Pixelated Technologies",
@@ -39,7 +39,8 @@
 			"default": "./dist/index.adminclient.js"
 		},
 		"./dist/components/*": "./dist/components/*",
-		"./css/*": "./dist/css/*"
+		"./css/*": "./dist/css/*",
+		"./scripts/*": "./dist/scripts/*"
 	},
 	"homepage": "https://github.com/brianwhaley/pixelated-components#readme",
 	"bugs": {
@@ -63,10 +64,10 @@
 		"buildClean": "rm -rf dist",
 		"tsc": "npx tsc --project tsconfig.json",
 		"tscClean": "rm -rf dist/{images,stories,tests}",
-		"rsync": "(cd src && tar -cf - $(find . -name \"*.css\" -o -name \"*.scss\" -o -name \"*.json\")) | tar -C dist -xf -",
-		"rsync1": "find src -type f \\( -name \"*.css\" -o -name \"*.scss\" -o -name \"*.json\" \\) -exec sh -c 'mkdir -p dist/$(dirname \"${1#src/}\") && cp \"$1\" dist/\"${1#src/}\"' _ {} \\;",
-		"rsync2": "rsync -a --include='*.css' --include='*.scss' --include='*.json' --include='*/' --exclude='*' src/ dist",
-		"validate-exports": "node scripts/validate-exports.cjs",
+		"rsync": "(cd src && tar -cf - $(find . -name \"*.css\" -o -name \"*.scss\" -o -name \"*.json\") scripts/) | tar -C dist -xf -",
+		"rsync1": "find src -type f \\( -name \"*.css\" -o -name \"*.scss\" -o -name \"*.json\" \\) -exec sh -c 'mkdir -p dist/$(dirname \"${1#src/}\") && cp \"$1\" dist/\"${1#src/}\"' _ {} \\; ; find src/scripts -type f -exec sh -c 'mkdir -p dist/$(dirname \"${1#src/}\") && cp \"$1\" dist/\"${1#src/}\"' _ {} \\;",
+		"rsync2": "rsync -a --include='*.css' --include='*.scss' --include='*.json' --include='scripts/**' --include='*/' --exclude='*' src/ dist",
+		"validate-exports": "npx tsx src/scripts/validate-exports.js",
 		"copy2brianwhaley": "rm -rf ../brianwhaley/node_modules/@pixelated-tech/components/dist && cp -r dist ../brianwhaley/node_modules/@pixelated-tech/components/",
 		"copy2informationfocus": "rm -rf ../informationfocus/node_modules/@pixelated-tech/components/dist && cp -r dist ../informationfocus/node_modules/@pixelated-tech/components/",
 		"copy2oaktreelandscaping": "rm -rf ../oaktreelandscaping/node_modules/@pixelated-tech/components/dist && cp -r dist ../oaktreelandscaping/node_modules/@pixelated-tech/components/",
@@ -84,7 +85,7 @@
 		"test:coverage": "vitest run --coverage",
 		"test:run": "vitest run",
 		"lint": "eslint --fix",
-		"release": "./scripts/release.sh"
+		"release": "./src/scripts/release.sh"
 	},
 	"scripts-old": {
 		"buildBabel": "npm run buildClean && NODE_ENV=production babel src --out-dir dist --copy-files",