@maggioli-design-system/magma-codemods 2.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,166 @@
+/**
+ * Programmatic entry point for the Magma v1 → v2 codemods.
+ *
+ * The CLI (`src/cli.ts`) is a thin wrapper around {@link runMigration}.
+ */
+import { execFileSync } from 'node:child_process';
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { globby } from 'globby';
+import { manifest as bundledManifest } from './manifest/manifest.js';
+import { unifiedDiff } from './report/diff.js';
+import { Reporter } from './report/reporter.js';
+import { transformAngular } from './surfaces/angular.js';
+import { transformCss } from './surfaces/css.js';
+import { transformHtml } from './surfaces/html.js';
+import { transformInlineTemplates } from './surfaces/inline-templates.js';
+import { transformReact } from './surfaces/react.js';
+const DEFAULT_IGNORE = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/.git/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/coverage/**',
+];
+const EXTENSIONS = ['html', 'htm', 'tsx', 'jsx', 'ts', 'css', 'scss'];
+/** Pick the transform for a file given the framework (or `auto` by extension). Returns null to skip. */
+export const routeFile = (file, framework) => {
+    const ext = extname(file).toLowerCase();
+    const css = {
+        surface: 'css',
+        run: (s, m, c) => transformCss(s, m, c, { scss: ext === '.scss' }),
+    };
+    const react = { surface: 'react', run: transformReact };
+    const html = { surface: 'html', run: transformHtml };
+    const angular = { surface: 'angular', run: transformAngular };
+    const inline = { surface: 'angular', run: transformInlineTemplates };
+    switch (framework) {
+        case 'css':
+            return css;
+        case 'react':
+            return react;
+        case 'html':
+            return html;
+        case 'angular':
+            if (ext === '.html' || ext === '.htm')
+                return angular;
+            if (ext === '.ts')
+                return inline;
+            return null;
+        case 'auto':
+        default:
+            if (ext === '.css' || ext === '.scss')
+                return css;
+            if (ext === '.tsx' || ext === '.jsx')
+                return react;
+            if (ext === '.ts')
+                return inline;
+            if (ext === '.html' || ext === '.htm')
+                return html;
+            return null;
+    }
+};
+const isGitClean = (cwd) => {
+    try {
+        const out = execFileSync('git', ['status', '--porcelain'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return out.trim() === '';
+    }
+    catch {
+        return 'not-a-repo';
+    }
+};
+const loadManifest = (manifestPath) => manifestPath ? JSON.parse(readFileSync(manifestPath, 'utf8')) : bundledManifest;
+/** Expand the input paths into a concrete, de-duplicated file list. */
+export const collectFiles = async (paths, cwd, ignore) => {
+    const files = new Set();
+    const patterns = [];
+    for (const p of paths) {
+        let isDir = false;
+        try {
+            isDir = statSync(p).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir)
+            patterns.push(`${p.replace(/\/$/, '')}/**/*.{${EXTENSIONS.join(',')}}`);
+        else
+            files.add(p);
+    }
+    if (patterns.length) {
+        const matched = await globby(patterns, {
+            cwd,
+            absolute: true,
+            onlyFiles: true,
+            ignore: [...DEFAULT_IGNORE, ...ignore],
+        });
+        for (const m of matched)
+            files.add(m);
+    }
+    return [...files].sort();
+};
+export const runMigration = async (options) => {
+    const cwd = options.cwd ?? process.cwd();
+    const write = options.write === true;
+    const manifest = loadManifest(options.manifestPath);
+    if (write && options.force !== true) {
+        const clean = isGitClean(cwd);
+        if (clean === false) {
+            throw new Error('Refusing to --write: the git working tree is not clean. Commit/stash first, or pass --force.');
+        }
+    }
+    const reporter = new Reporter({
+        fromVersion: manifest.fromVersion,
+        toVersion: manifest.toVersion,
+        dryRun: !write,
+    });
+    const ctxBase = {
+        only: options.only ? new Set(options.only) : undefined,
+        skip: options.skip ? new Set(options.skip) : undefined,
+    };
+    const files = await collectFiles(options.paths, cwd, options.ignore ?? []);
+    for (const file of files) {
+        const route = routeFile(file, options.framework);
+        if (!route)
+            continue;
+        let source;
+        try {
+            source = readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            reporter.addError({
+                file,
+                surface: route.surface,
+                message: `cannot read file: ${error.message}`,
+            });
+            continue;
+        }
+        try {
+            const result = route.run(source, manifest, { file, ...ctxBase });
+            const fileReport = {
+                file,
+                surface: route.surface,
+                changed: result.changed,
+                findings: result.findings,
+                diff: result.changed ? unifiedDiff(file, source, result.output) : undefined,
+            };
+            reporter.addFile(fileReport);
+            if (write && result.changed)
+                writeFileSync(file, result.output);
+        }
+        catch (error) {
+            reporter.addError({ file, surface: route.surface, message: error.message });
+        }
+    }
+    const report = reporter.build();
+    if (options.reportPath)
+        writeFileSync(options.reportPath, reporter.toJSON(report));
+    return { report, reporter };
+};
+export * from './report/types.js';
+export { exitCode } from './report/reporter.js';

package/dist/manifest/manifest.d.ts

@@ -0,0 +1,3 @@
+import { type Manifest } from './schema.js';
+export declare const manifest: Manifest;
+export default manifest;

package/dist/manifest/manifest.generated.d.ts

@@ -0,0 +1,2 @@
+import { type Manifest } from './schema.js';
+export declare const generatedManifest: Manifest;