@pie-element/cli 0.1.1

package/src/lib/upstream/sync-strategy.ts

@@ -0,0 +1,61 @@
+/**
+ * Strategy pattern for sync operations
+ */
+import type { Logger } from '../../utils/logger.js';
+import type { CompatibilityReport } from '../../utils/compatibility.js';
+
+export interface SyncConfig {
+  pieElements: string;
+  pieLib: string;
+  pieElementsNg: string;
+
+  // What to sync
+  syncControllers: boolean;
+  syncReactComponents: boolean;
+  syncPieLib: boolean;
+
+  // Filters
+  pieLibPackages?: string[];
+
+  // Options
+  skipDemos: boolean;
+  upstreamCommit: string;
+}
+
+export interface SyncContext {
+  config: SyncConfig;
+  logger: Logger;
+  packageFilter?: string;
+  compatibilityReport?: CompatibilityReport;
+}
+
+export interface SyncResult {
+  count: number;
+  packageNames: string[];
+}
+
+/**
+ * Base interface for sync strategies
+ */
+export interface SyncStrategy {
+  /**
+   * Get the name of this strategy
+   */
+  getName(): string;
+
+  /**
+   * Check if this strategy should run based on config
+   */
+  shouldRun(config: SyncConfig): boolean;
+
+  /**
+   * Execute the sync operation
+   * @returns Sync result with count and package names
+   */
+  execute(context: SyncContext): Promise<SyncResult>;
+
+  /**
+   * Get a human-readable description of what this strategy syncs
+   */
+  getDescription(): string;
+}

package/src/lib/upstream/sync-summary.ts

@@ -0,0 +1,194 @@
+/**
+ * Summary utilities for sync operations
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Logger } from '../../utils/logger.js';
+import type { CompatibilityReport } from '../../utils/compatibility.js';
+import { EXCLUDED_UPSTREAM_ELEMENTS } from './sync-constants.js';
+
+export interface SyncSummary {
+  controllersSync: number;
+  reactComponentsSynced: number;
+  pieLibPackagesSynced: number;
+  totalPackagesSynced: number;
+  blockedElements: number;
+  blockedPieLib: number;
+  syncedPackageNames: string[];
+}
+
+/**
+ * Get all currently synced elements from packages/elements-react directory
+ */
+function getAllSyncedElements(pieElementsNgPath: string): string[] {
+  try {
+    const elementsReactPath = join(pieElementsNgPath, 'packages', 'elements-react');
+    const entries = readdirSync(elementsReactPath, { withFileTypes: true });
+    return entries
+      .filter((entry) => {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) {
+          return false;
+        }
+        if (
+          EXCLUDED_UPSTREAM_ELEMENTS.includes(
+            entry.name as (typeof EXCLUDED_UPSTREAM_ELEMENTS)[number]
+          )
+        ) {
+          return false;
+        }
+        return existsSync(join(elementsReactPath, entry.name, 'package.json'));
+      })
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Print a concise summary of the sync operation
+ */
+export function printSyncSummary(
+  summary: SyncSummary,
+  compatibilityReport: CompatibilityReport | null,
+  pieElementsNgPath: string,
+  logger: Logger
+): void {
+  logger.info('');
+  logger.info('─'.repeat(60));
+  logger.info('');
+
+  // Show changes from this sync run
+  if (summary.syncedPackageNames.length > 0) {
+    const elementCount = summary.syncedPackageNames.length;
+    logger.success(`${elementCount} element${elementCount > 1 ? 's' : ''} synced in this run`);
+    for (const pkg of summary.syncedPackageNames.sort()) {
+      logger.info(`  • ${pkg}`);
+    }
+    logger.info('');
+  }
+
+  // Show complete overview of all synced and blocked elements
+  logger.info('Complete Overview:');
+  logger.info('');
+
+  // All currently synced elements
+  const allSyncedElements = getAllSyncedElements(pieElementsNgPath);
+  if (allSyncedElements.length > 0) {
+    logger.success(`${allSyncedElements.length} elements currently synced`);
+    for (const element of allSyncedElements) {
+      logger.info(`  • ${element}`);
+    }
+  } else {
+    logger.info('No elements synced');
+  }
+
+  const totalBlocked = summary.blockedElements + summary.blockedPieLib;
+  if (totalBlocked > 0 && compatibilityReport) {
+    logger.info('');
+    logger.warn(`${totalBlocked} packages blocked from sync (ESM incompatible)`);
+
+    // List blocked elements
+    const blockedElementNames = Object.keys(compatibilityReport.blockedElements).sort();
+    if (blockedElementNames.length > 0) {
+      logger.info('');
+      logger.info('Blocked elements:');
+      for (const element of blockedElementNames) {
+        const blockers = compatibilityReport.blockedElements[element];
+        const firstBlocker = blockers[0] || 'Unknown blocker';
+        logger.info(`  • ${element}: ${firstBlocker}`);
+      }
+    }
+
+    // List blocked pie-lib packages
+    const blockedPieLibNames = Object.entries(compatibilityReport.pieLibDetails)
+      .filter(([, details]) => !details.compatible)
+      .map(([pkg]) => pkg)
+      .sort();
+
+    if (blockedPieLibNames.length > 0) {
+      logger.info('');
+      logger.info('Blocked @pie-lib packages:');
+      for (const pkg of blockedPieLibNames) {
+        const details = compatibilityReport.pieLibDetails[pkg];
+        const firstBlocker = details.blockers[0] || 'Unknown blocker';
+        logger.info(`  • @pie-lib/${pkg}: ${firstBlocker}`);
+      }
+    }
+
+    // Show summary of blocker types
+    if (logger.isVerbose()) {
+      logger.info('');
+      logger.info('Blocker summary by type:');
+
+      // Group blockers by type
+      const blockersByType = new Map<string, string[]>();
+
+      // Analyze element blockers
+      for (const [element, blockers] of Object.entries(compatibilityReport.blockedElements)) {
+        for (const blocker of blockers) {
+          const match = blocker.match(/^(.+?)\s*-\s*(.+)$/);
+          if (match) {
+            const [, dep, reason] = match;
+            const key = `${dep}: ${reason}`;
+            if (!blockersByType.has(key)) {
+              blockersByType.set(key, []);
+            }
+            const pkgList = blockersByType.get(key);
+            if (pkgList) {
+              pkgList.push(element);
+            }
+          }
+        }
+      }
+
+      // Analyze pie-lib blockers
+      for (const [pkg, details] of Object.entries(compatibilityReport.pieLibDetails)) {
+        if (!details.compatible) {
+          for (const blocker of details.blockers) {
+            const match = blocker.match(/^(.+?)\s*-\s*(.+)$/);
+            if (match) {
+              const [, dep, reason] = match;
+              const key = `${dep}: ${reason}`;
+              if (!blockersByType.has(key)) {
+                blockersByType.set(key, []);
+              }
+              const pkgList = blockersByType.get(key);
+              if (pkgList) {
+                pkgList.push(`@pie-lib/${pkg}`);
+              }
+            }
+          }
+        }
+      }
+
+      const sortedBlockers = Array.from(blockersByType.entries()).sort(
+        (a, b) => b[1].length - a[1].length
+      );
+
+      for (const [blocker, packages] of sortedBlockers) {
+        logger.info(`  • ${packages.length} package${packages.length > 1 ? 's' : ''}: ${blocker}`);
+        for (const pkg of packages) {
+          logger.info(`    - ${pkg}`);
+        }
+      }
+    }
+  }
+
+  logger.info('');
+}
+
+/**
+ * Create an empty summary
+ */
+export function createEmptySummary(): SyncSummary {
+  return {
+    controllersSync: 0,
+    reactComponentsSynced: 0,
+    pieLibPackagesSynced: 0,
+    totalPackagesSynced: 0,
+    blockedElements: 0,
+    blockedPieLib: 0,
+    syncedPackageNames: [],
+  };
+}

package/src/lib/upstream/sync-transforms.ts

@@ -0,0 +1,154 @@
+/**
+ * Centralized transformation pipeline for upstream sync operations
+ *
+ * This module consolidates all source code transformations into a single,
+ * composable pipeline to reduce duplication and ensure consistent transformations
+ * across all sync strategies.
+ */
+
+import {
+  transformLodashToLodashEs,
+  transformPieFrameworkEventImports,
+  transformControllerUtilsImports,
+  transformSharedPackageImports,
+  transformMathquillImports,
+  inlineEditableHtmlConstants,
+  reexportTokenTypes,
+  transformSsrRequireToReactLazy,
+  inlineConfigureDefaults,
+  transformConfigureUtilsImports,
+  transformSelfReferentialImports,
+  transformPackageJsonLodash,
+  transformPackageJsonRecharts,
+  transformPackageJsonPieEvents,
+  transformPackageJsonControllerUtils,
+  transformPackageJsonSharedPackages,
+  transformPackageJsonMathquill,
+  fixStyledComponentTypes,
+  fixExportedFunctionTypes,
+  transformMenuToInlineMenu,
+  addInlineMenuExport,
+  transformMathQuillInterface,
+} from './sync-imports.js';
+import type { PackageJson } from '../../utils/package-json.js';
+
+export interface TransformOptions {
+  /** Path relative to package root (e.g., "configure/src/utils.js") */
+  relativePath?: string;
+  /** Source file path for context (e.g., "/path/to/file.js") */
+  sourcePath?: string;
+  /** Package name (e.g., "@pie-element/fraction-model") */
+  packageName?: string;
+  /** Whether to include configure-specific transforms */
+  includeConfigure?: boolean;
+  /** Whether to include pie-lib-specific transforms */
+  includePieLib?: boolean;
+}
+
+/**
+ * Apply all standard source code transformations in the correct order
+ *
+ * This ensures consistent transformation across all sync strategies:
+ * 1. lodash → lodash-es (ESM compatibility)
+ * 2. @pie-framework event packages → internal packages
+ * 3. @pie-lib/controller-utils → @pie-framework/controller-utils
+ * 4. @pie-lib shared packages → @pie-element/shared-*
+ * 5. @pie-framework/mathquill → @pie-element/shared-mathquill
+ * 6. @mui/material/Menu → InlineMenu from @pie-lib/render-ui
+ * 7. Self-referential imports → relative imports
+ * 8. Configure-specific transforms (if enabled)
+ * 9. Pie-lib-specific transforms (if enabled)
+ * 10. Fix styled component TypeScript type inference errors
+ */
+export function applySourceTransforms(content: string, options: TransformOptions = {}): string {
+  let transformed = content;
+
+  // Core transforms (always applied)
+  transformed = transformLodashToLodashEs(transformed);
+  transformed = transformPieFrameworkEventImports(transformed);
+  transformed = transformControllerUtilsImports(transformed);
+  transformed = transformSharedPackageImports(transformed);
+  transformed = transformMathquillImports(transformed);
+  transformed = transformMathQuillInterface(transformed);
+  transformed = transformMenuToInlineMenu(transformed);
+
+  // Transform self-referential imports to relative paths
+  if (options.packageName && options.relativePath) {
+    transformed = transformSelfReferentialImports(
+      transformed,
+      options.packageName,
+      options.relativePath
+    );
+  }
+
+  // Configure-specific transforms
+  if (options.includeConfigure) {
+    transformed = inlineConfigureDefaults(transformed);
+    if (options.relativePath) {
+      transformed = transformConfigureUtilsImports(transformed, options.relativePath);
+    }
+  }
+
+  // Pie-lib-specific transforms
+  if (options.includePieLib) {
+    transformed = inlineEditableHtmlConstants(transformed);
+    if (options.sourcePath) {
+      transformed = reexportTokenTypes(transformed, options.sourcePath);
+      transformed = addInlineMenuExport(transformed, options.sourcePath);
+    }
+    transformed = transformSsrRequireToReactLazy(transformed);
+  }
+
+  // TypeScript fixes (always applied)
+  transformed = fixStyledComponentTypes(transformed);
+  transformed = fixExportedFunctionTypes(transformed, options.sourcePath);
+
+  return transformed;
+}
+
+/**
+ * Apply all standard package.json transformations
+ *
+ * Ensures consistent dependency transformations across all packages:
+ * 1. lodash → lodash-es
+ * 2. @pie-framework event packages → internal packages
+ * 3. @pie-lib/controller-utils → @pie-framework/controller-utils
+ * 4. @pie-lib shared packages → @pie-element/shared-*
+ * 5. @pie-framework/mathquill → @pie-element/shared-mathquill
+ */
+export function applyPackageJsonTransforms<T extends PackageJson>(pkg: T): T {
+  let transformed = pkg;
+
+  transformed = transformPackageJsonLodash(transformed);
+  transformed = transformPackageJsonRecharts(transformed);
+  transformed = transformPackageJsonPieEvents(transformed);
+  transformed = transformPackageJsonControllerUtils(transformed);
+  transformed = transformPackageJsonSharedPackages(transformed);
+  transformed = transformPackageJsonMathquill(transformed);
+
+  return transformed;
+}
+
+/**
+ * Create a transform pipeline for controller files
+ */
+export function createControllerTransformPipeline(packageName?: string) {
+  return (content: string, relativePath?: string) =>
+    applySourceTransforms(content, { relativePath, packageName, includeConfigure: false });
+}
+
+/**
+ * Create a transform pipeline for React component files
+ */
+export function createReactComponentTransformPipeline(packageName?: string) {
+  return (content: string, relativePath?: string) =>
+    applySourceTransforms(content, { relativePath, packageName, includeConfigure: true });
+}
+
+/**
+ * Create a transform pipeline for pie-lib files
+ */
+export function createPieLibTransformPipeline() {
+  return (content: string, sourcePath?: string) =>
+    applySourceTransforms(content, { sourcePath, includePieLib: true });
+}

package/src/lib/upstream/sync-vite-config.ts

@@ -0,0 +1,243 @@
+/**
+ * Vite configuration generation for sync operations
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createExternalFunction } from './sync-externals.js';
+
+/**
+ * Detect the actual file extension for a source file
+ */
+function detectFileExtension(basePath: string): string | null {
+  if (existsSync(`${basePath}.tsx`)) return '.tsx';
+  if (existsSync(`${basePath}.ts`)) return '.ts';
+  return null;
+}
+
+/**
+ * Detect entry points for an element package
+ */
+export function detectElementEntryPoints(elementDir: string): Record<string, string> {
+  const entryPoints: Record<string, string> = {};
+
+  // Main index
+  const indexExt = detectFileExtension(join(elementDir, 'src/index'));
+  if (indexExt) {
+    entryPoints.index = `src/index${indexExt}`;
+  }
+
+  // Controller
+  const controllerExt = detectFileExtension(join(elementDir, 'src/controller/index'));
+  if (controllerExt) {
+    entryPoints['controller/index'] = `src/controller/index${controllerExt}`;
+  }
+
+  // Configure
+  const configureExt = detectFileExtension(join(elementDir, 'src/configure/index'));
+  if (configureExt) {
+    entryPoints['configure/index'] = `src/configure/index${configureExt}`;
+  }
+
+  // Delivery
+  const deliveryExt = detectFileExtension(join(elementDir, 'src/delivery/index'));
+  if (deliveryExt) {
+    entryPoints['delivery/index'] = `src/delivery/index${deliveryExt}`;
+  }
+
+  return entryPoints;
+}
+
+/**
+ * Generate Vite config content for an element package
+ */
+export function generateElementViteConfig(entryPoints: Record<string, string>): string {
+  if (Object.keys(entryPoints).length === 0) {
+    throw new Error('No entry points found for element');
+  }
+
+  const entryJson = JSON.stringify(entryPoints, null, 8).replace(/^/gm, '      ');
+
+  return `import { resolve } from 'node:path';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+export default defineConfig(({ mode }) => {
+  // Demo mode: serve the docs/demo directory
+  if (mode === 'demo') {
+    return {
+      plugins: [react()],
+      root: 'docs/demo',
+      server: {
+        port: 5174,
+      },
+    };
+  }
+
+  // Build mode: build the library
+  return {
+    plugins: [react()],
+    build: {
+      lib: {
+        entry: ${entryJson.trimStart()},
+        formats: ['es'],
+      },
+      rollupOptions: {
+        external: ${createExternalFunction('element')},
+        output: {
+          preserveModules: true,
+          preserveModulesRoot: 'src',
+        },
+      },
+    },
+  };
+});
+`;
+}
+
+/**
+ * Generate Vite config content for a pie-lib package
+ */
+export function generatePieLibViteConfig(packageName?: string, packageDir?: string): string {
+  // Detect entry point extension if package directory provided
+  let entryPoint = 'src/index.ts';
+  if (packageDir) {
+    const ext = detectFileExtension(join(packageDir, 'src/index'));
+    if (ext) {
+      entryPoint = `src/index${ext}`;
+    }
+  }
+
+  // Special config for math-rendering wrapper (externalizes adapter package)
+  if (packageName === 'math-rendering') {
+    return `import { resolve } from 'node:path';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: {
+        index: resolve(__dirname, '${entryPoint}'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: (id) => {
+        return (
+          /^@pie-element\\/shared-/.test(id) ||
+          id === '@pie-element/shared-math-rendering-mathjax' ||
+          /^@pie-lib\\//.test(id) ||
+          ['debug'].includes(id)
+        );
+      },
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+    },
+  },
+});
+`;
+  }
+
+  // Special config for test-utils (includes testing library externals)
+  if (packageName === 'test-utils') {
+    return `import { resolve } from 'node:path';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    lib: {
+      entry: {
+        index: resolve(__dirname, '${entryPoint}'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: ${createExternalFunction('pielib')},
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+    },
+  },
+});
+`;
+  }
+
+  // Special config for editable-html-tip-tap (externalizes prosemirror and tiptap)
+  if (packageName === 'editable-html-tip-tap') {
+    return `import { resolve } from 'node:path';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    lib: {
+      entry: {
+        index: resolve(__dirname, '${entryPoint}'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: (id) => {
+        return (
+          /^react($|\\/)/.test(id) ||
+          /^react-dom($|\\/)/.test(id) ||
+          /^@pie-lib\\//.test(id) ||
+          /^@pie-element\\//.test(id) ||
+          /^@pie-element\\//.test(id) ||
+          /^@pie-framework\\//.test(id) ||
+          /^@mui\\//.test(id) ||
+          /^@emotion\\//.test(id) ||
+          /^d3-/.test(id) ||
+          /^@testing-library\\//.test(id) ||
+          id === 'lodash-es' ||
+          /^lodash-es\\//.test(id) ||
+          /^styled-components/.test(id) ||
+          id === 'konva' || /^konva\\//.test(id) ||
+          id === 'react-konva' || /^react-konva\\//.test(id) ||
+          id === '@mdi/react' || /^@mdi\\/react\\//.test(id) ||
+          id === '@mdi/js' || /^@mdi\\/js\\//.test(id) ||
+          /^prosemirror-/.test(id) ||
+          /^@tiptap\\//.test(id) ||
+          ['prop-types', 'classnames', 'debug', 'i18next', 'humps', 'mathjs', 'react-jss', 'js-combinatorics', '@dnd-kit/core', 'react-transition-group'].includes(id)
+        );
+      },
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+    },
+  },
+});
+`;
+  }
+
+  // Default pie-lib config
+  return `import { resolve } from 'node:path';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    lib: {
+      entry: {
+        index: resolve(__dirname, '${entryPoint}'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: ${createExternalFunction('pielib')},
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: 'src',
+      },
+    },
+  },
+});
+`;
+}

package/src/types/es-module-lexer.d.ts

@@ -0,0 +1,4 @@
+declare module 'es-module-lexer' {
+  export const init: Promise<void>;
+  export function parse(source: string): [Array<{ s: number; e: number }>, unknown];
+}