ember-codemod-v1-to-v2 0.6.2 → 0.7.0

package/README.md

@@ -102,7 +102,12 @@ To better meet your needs, consider cloning the repo and running the codemod loc
 
 ```sh
 cd <your/cloned/repo>
-./bin/ember-codemod-v1-to-v2.js --root=<your/project/path>
+
+# Compile TypeScript
+pnpm build
+
+# Run codemod
+./dist/bin/ember-codemod-v1-to-v2.js --root=<your/project/path>
 ```
 
 You can also look at another codemod called [`ember-addon-migrator`](https://github.com/NullVoxPopuli/ember-addon-migrator).

package/dist/bin/ember-codemod-v1-to-v2.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// eslint-disable-next-line n/shebang
+'use strict';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { runCodemod } from '../src/index.js';
+// Provide a title to the process in `ps`
+process.title = 'ember-codemod-v1-to-v2';
+// Set codemod options
+const argv = yargs(hideBin(process.argv))
+    .option('addon-location', {
+    describe: 'Location of the addon package',
+    type: 'string',
+})
+    .option('root', {
+    describe: 'Location of your Ember addon',
+    type: 'string',
+})
+    .option('test-app-location', {
+    describe: 'Location of the test-app package',
+    type: 'string',
+})
+    .option('test-app-name', {
+    describe: 'Name of the test-app package',
+    type: 'string',
+})
+    .parseSync();
+function castEmptyStringToUndefined(value) {
+    return value === '' ? undefined : value;
+}
+const codemodOptions = {
+    addonLocation: castEmptyStringToUndefined(argv['addon-location']),
+    projectRoot: argv['root'] ?? process.cwd(),
+    testAppLocation: castEmptyStringToUndefined(argv['test-app-location']),
+    testAppName: castEmptyStringToUndefined(argv['test-app-name']),
+};
+runCodemod(codemodOptions);

package/dist/blueprints/ember-addon/__addonLocation__/.eslintignore

@@ -0,0 +1,8 @@
+# unconventional js
+/blueprints/*/files/
+
+# compiled output
+/dist/
+
+# misc
+/coverage/

package/dist/blueprints/ember-addon/__addonLocation__/addon-main.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const { addonV1Shim } = require('@embroider/addon-shim');
+
+module.exports = addonV1Shim(__dirname);

package/dist/blueprints/ember-addon/__addonLocation__/babel.config.json

@@ -0,0 +1,9 @@
+{
+<% if (options.packages.addon.hasTypeScript) { %>  "presets": [["@babel/preset-typescript"]],
+<% } %>  "plugins": [
+    "@embroider/addon-dev/template-colocation-plugin",<% if (options.packages.addon.hasTypeScript) { %>
+    ["@babel/plugin-transform-typescript", { "allowDeclareFields": true }],<% } %>
+    ["@babel/plugin-proposal-decorators", { "version": "legacy" }],
+    "@babel/plugin-proposal-class-properties"
+  ]
+}

package/dist/blueprints/ember-addon/__addonLocation__/rollup.config.mjs

@@ -0,0 +1,64 @@
+<% if (options.packages.addon.hasTypeScript) { %>import typescript from 'rollup-plugin-ts';<% } else { %>import { babel } from '@rollup/plugin-babel';<% } %>
+import copy from 'rollup-plugin-copy';
+import { Addon } from '@embroider/addon-dev/rollup';
+
+const addon = new Addon({
+  srcDir: 'src',
+  destDir: 'dist',
+});
+
+export default {
+  // This provides defaults that work well alongside `publicEntrypoints` below.
+  // You can augment this if you need to.
+  output: addon.output(),
+
+  plugins: [
+    // These are the modules that users should be able to import from your
+    // addon. Anything not listed here may get optimized away.
+    addon.publicEntrypoints([<%= context.addon.publicEntrypoints.map((filePath) => `'${filePath}'`).join(', ') %>]),
+
+    // These are the modules that should get reexported into the traditional
+    // "app" tree. Things in here should also be in publicEntrypoints above, but
+    // not everything in publicEntrypoints necessarily needs to go here.
+    addon.appReexports([<%= context.addon.appReexports.map((filePath) => `'${filePath}'`).join(', ') %>]),
+
+    // Follow the V2 Addon rules about dependencies. Your code can import from
+    // `dependencies` and `peerDependencies` as well as standard Ember-provided
+    // package names.
+    addon.dependencies(),
+
+<% if (options.packages.addon.hasTypeScript) { %>    // compile TypeScript to latest JavaScript, including Babel transpilation
+    typescript({
+      transpiler: 'babel',
+      browserslist: false,
+      transpileOnly: false,
+    }),
+<% } else { %>    // This babel config should *not* apply presets or compile away ES modules.
+    // It exists only to provide development niceties for you, like automatic
+    // template colocation.
+    //
+    // By default, this will load the actual babel config from the file
+    // babel.config.json.
+    babel({
+      babelHelpers: 'bundled',
+    }),
+<% } %>
+    // Ensure that standalone .hbs files are properly integrated as Javascript.
+    addon.hbs(),
+
+    // addons are allowed to contain imports of .css files, which we want rollup
+    // to leave alone and keep in the published output.
+    addon.keepAssets(['**/*.css']),
+
+    // Remove leftover build artifacts when starting a new build.
+    addon.clean(),
+
+    // Copy Readme and License into published package
+    copy({
+      targets: [
+        { src: '../README.md', dest: '.' },
+        { src: '../LICENSE.md', dest: '.' },
+      ],
+    }),
+  ],
+};

package/dist/blueprints/ember-addon/__addonLocation__/unpublished-development-types/index.d.ts

@@ -0,0 +1,14 @@
+// Add any types here that you need for local development only.
+// These will *not* be published as part of your addon, so be careful that your published code does not rely on them!
+<% if (options.packages.addon.hasGlint) { %>
+import '@glint/environment-ember-loose';
+
+declare module '@glint/environment-ember-loose/registry' {
+  // Remove this once entries have been added! 👇
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  export default interface Registry {
+    // Add any registry entries from other addons here that your addon itself uses (in non-strict mode templates)
+    // See https://typed-ember.gitbook.io/glint/using-glint/ember/using-addons
+  }
+}
+<% } %>

package/dist/blueprints/ember-addon/__gitignore__

@@ -0,0 +1,24 @@
+# compiled output
+/dist/
+
+# dependencies
+/node_modules/
+
+# misc
+/.env*
+/.pnp*
+/.eslintcache
+/coverage/
+/npm-debug.log*
+/testem.log
+/yarn-error.log
+
+# ember-try
+/.node_modules.ember-try/
+/npm-shrinkwrap.json.ember-try
+/package.json.ember-try
+/package-lock.json.ember-try
+/yarn.lock.ember-try
+
+# broccoli-debug
+/DEBUG/

package/dist/blueprints/ember-addon/__testAppLocation__/ember-cli-build.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const EmberApp = require('ember-cli/lib/broccoli/ember-app');
+
+module.exports = function (defaults) {
+  const app = new EmberApp(defaults, {
+    // Add options here
+    autoImport: {
+      watchDependencies: ['<%= options.packages.addon.name %>'],
+    },
+  });
+
+  const { maybeEmbroider } = require('@embroider/test-setup');
+
+  return maybeEmbroider(app);
+};

package/dist/blueprints/ember-addon/__testAppLocation__/types/global.d.ts

@@ -0,0 +1,7 @@
+// Types for compiled templates
+declare module '<%= options.packages.testApp.name %>/templates/*' {
+  import { TemplateFactory } from 'ember-cli-htmlbars';
+
+  const tmpl: TemplateFactory;
+  export default tmpl;
+}

package/dist/blueprints/ember-addon/package.json

@@ -0,0 +1,69 @@
+<% if (options.packageManager.isNpm) { %>{
+  "name": "<%= options.packages.addon.name %>",
+  "version": "<%= options.packages.addon.version %>",
+  "private": true,
+  "repository": "",
+  "license": "MIT",
+  "author": "",
+  "workspaces": [
+    "<%= options.locations.addon %>",
+    "<%= options.locations.testApp %>"
+  ],
+  "scripts": {
+    "build": "npm run build --workspace <%= options.packages.addon.name %>",
+    "lint": "npm run lint --workspaces --if-present",
+    "lint:fix": "npm run lint:fix --workspaces --if-present",
+    "prepare": "npm run build",
+    "start": "concurrently 'npm:start:*' --restart-after 5000 --prefix-colors cyan,white,yellow",
+    "start:addon": "npm start --workspace <%= options.packages.addon.name %>",
+    "start:test-app": "npm start --workspace <%= options.packages.testApp.name %>",
+    "test": "npm run test --workspaces --if-present"
+  },
+  "devDependencies": {
+    "concurrently": "<%= context.projectRoot.devDependencies['concurrently'] %>"
+  }
+}<% } else if (options.packageManager.isPnpm) { %>{
+  "name": "<%= options.packages.addon.name %>",
+  "version": "<%= options.packages.addon.version %>",
+  "private": true,
+  "repository": "",
+  "license": "MIT",
+  "author": "",
+  "scripts": {
+    "build": "pnpm --filter <%= options.packages.addon.name %> build",
+    "lint": "pnpm --filter '*' lint",
+    "lint:fix": "pnpm --filter '*' lint:fix",
+    "prepare": "pnpm build",
+    "start": "concurrently 'npm:start:*' --restart-after 5000 --prefix-colors cyan,white,yellow",
+    "start:addon": "pnpm --filter <%= options.packages.addon.name %> start",
+    "start:test-app": "pnpm --filter <%= options.packages.testApp.name %> start",
+    "test": "pnpm --filter '*' test"
+  },
+  "devDependencies": {
+    "concurrently": "<%= context.projectRoot.devDependencies['concurrently'] %>"
+  }
+}<% } else if (options.packageManager.isYarn) { %>{
+  "name": "<%= options.packages.addon.name %>",
+  "version": "<%= options.packages.addon.version %>",
+  "private": true,
+  "repository": "",
+  "license": "MIT",
+  "author": "",
+  "workspaces": [
+    "<%= options.locations.addon %>",
+    "<%= options.locations.testApp %>"
+  ],
+  "scripts": {
+    "build": "yarn workspace <%= options.packages.addon.name %> run build",
+    "lint": "yarn workspaces run lint",
+    "lint:fix": "yarn workspaces run lint:fix",
+    "prepare": "yarn build",
+    "start": "concurrently 'npm:start:*' --restart-after 5000 --prefix-colors cyan,white,yellow",
+    "start:addon": "yarn workspace <%= options.packages.addon.name %> run start",
+    "start:test-app": "yarn workspace <%= options.packages.testApp.name %> run start",
+    "test": "yarn workspaces run test"
+  },
+  "devDependencies": {
+    "concurrently": "<%= context.projectRoot.devDependencies['concurrently'] %>"
+  }
+}<% } %>

package/dist/blueprints/ember-addon/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - '<%= options.locations.addon %>'
+  - '<%= options.locations.testApp %>'

package/{src → dist/src}/index.js

@@ -1,5 +1,4 @@
 import { migrateEmberAddon } from './migration/index.js';
-
 export function runCodemod(codemodOptions) {
-  migrateEmberAddon(codemodOptions);
+    migrateEmberAddon(codemodOptions);
 }

package/dist/src/migration/ember-addon/index.js

@@ -0,0 +1,22 @@
+import { analyzeAddon, createFilesFromBlueprint, createOptions, moveAddonFiles, moveProjectRootFiles, moveTestAppFiles, updateAddonPackageJson, updateAddonTsConfigJson, updateTestAppPackageJson, updateTestAppTsConfigJson, } from './steps/index.js';
+export function migrateEmberAddon(codemodOptions) {
+    const options = createOptions(codemodOptions);
+    const { isV1Addon } = options.packages.addon;
+    // Guarantee idempotency
+    if (!isV1Addon) {
+        return;
+    }
+    // Prepare for migration
+    const context = analyzeAddon(options);
+    // Preserve code
+    moveAddonFiles(options);
+    moveTestAppFiles(options);
+    moveProjectRootFiles(options);
+    // Get the latest code from blueprint
+    createFilesFromBlueprint(context, options);
+    // Fine-tune individual files
+    updateAddonPackageJson(context, options);
+    updateAddonTsConfigJson(options);
+    updateTestAppPackageJson(options);
+    updateTestAppTsConfigJson(options);
+}

package/dist/src/migration/ember-addon/steps/analyze-addon.js

@@ -0,0 +1,70 @@
+import { findFiles, renamePathByDirectory } from '@codemod-utils/files';
+import { getVersion } from '../../../utils/blueprints.js';
+function getAppReexports(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('app/**/*.js', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'app',
+            to: '',
+        });
+    })
+        .sort();
+}
+function getProjectRootDevDependencies(options) {
+    return {
+        concurrently: getVersion('concurrently', options),
+    };
+}
+function getPublicAssets(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('public/**/*', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'public',
+            to: '',
+        });
+    })
+        .sort();
+}
+function getPublicEntrypoints(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('{addon,addon-test-support}/**/*.{js,ts}', {
+        projectRoot,
+    });
+    return filePaths
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'addon',
+            to: '',
+        });
+    })
+        .map((filePath) => {
+        return renamePathByDirectory(filePath, {
+            from: 'addon-test-support',
+            to: 'test-support',
+        });
+    })
+        .map((filePath) => {
+        return filePath.replace(/ts$/, 'js');
+    })
+        .sort();
+}
+export function analyzeAddon(options) {
+    return {
+        addon: {
+            appReexports: getAppReexports(options),
+            publicAssets: getPublicAssets(options),
+            publicEntrypoints: getPublicEntrypoints(options),
+        },
+        projectRoot: {
+            devDependencies: getProjectRootDevDependencies(options),
+        },
+    };
+}

package/dist/src/migration/ember-addon/steps/create-files-from-blueprint.js

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { processTemplate } from '@codemod-utils/blueprints';
+import { createFiles, findFiles } from '@codemod-utils/files';
+import { blueprintsRoot } from '../../../utils/blueprints.js';
+function getFilesToSkip(options) {
+    const { packageManager, packages } = options;
+    const files = new Set();
+    if (!packages.addon.hasTypeScript) {
+        files.add('__addonLocation__/unpublished-development-types/index.d.ts');
+        files.add('__testAppLocation__/types/global.d.ts');
+    }
+    if (!packageManager.isPnpm) {
+        files.add('pnpm-workspace.yaml');
+    }
+    return [...files];
+}
+function resolveBlueprintFilePath(blueprintFilePath, options) {
+    const { locations } = options;
+    return blueprintFilePath
+        .replace('__addonLocation__', locations.addon)
+        .replace('__gitignore__', '.gitignore')
+        .replace('__testAppLocation__', locations.testApp);
+}
+export function createFilesFromBlueprint(context, options) {
+    const filesToSkip = getFilesToSkip(options);
+    const cwd = join(blueprintsRoot, 'ember-addon');
+    const blueprintFilePaths = findFiles('**/*', {
+        ignoreList: filesToSkip,
+        projectRoot: cwd,
+    });
+    const fileMap = new Map(blueprintFilePaths.map((blueprintFilePath) => {
+        const filePath = resolveBlueprintFilePath(blueprintFilePath, options);
+        const blueprintFile = readFileSync(join(cwd, blueprintFilePath), 'utf8');
+        const file = processTemplate(blueprintFile, {
+            context,
+            options,
+        });
+        return [filePath, file];
+    }));
+    createFiles(fileMap, options);
+}

package/dist/src/migration/ember-addon/steps/create-options.js

@@ -0,0 +1,73 @@
+import { findFiles, unionize } from '@codemod-utils/files';
+import { readPackageJson, validatePackageJson } from '@codemod-utils/json';
+function analyzePackageJson(codemodOptions) {
+    const { projectRoot } = codemodOptions;
+    const packageJson = readPackageJson({ projectRoot });
+    validatePackageJson(packageJson);
+    const { dependencies, devDependencies, 'ember-addon': emberAddon, name, version, } = packageJson;
+    const projectDependencies = new Map([
+        ...Object.entries(dependencies ?? {}),
+        ...Object.entries(devDependencies ?? {}),
+    ]);
+    return {
+        dependencies: projectDependencies,
+        hasGlint: projectDependencies.has('@glint/core'),
+        hasTypeScript: projectDependencies.has('typescript'),
+        isV1Addon: Boolean(emberAddon),
+        name,
+        version,
+    };
+}
+function analyzePackageManager(codemodOptions) {
+    const { projectRoot } = codemodOptions;
+    const mapping = new Map([
+        ['package-lock.json', 'npm'],
+        ['pnpm-lock.yaml', 'pnpm'],
+        ['yarn.lock', 'yarn'],
+    ]);
+    const lockFiles = [...mapping.keys()];
+    const filePaths = findFiles(unionize(lockFiles), {
+        projectRoot,
+    });
+    if (filePaths.length !== 1) {
+        console.warn('WARNING: Package manager is unknown. Yarn will be assumed.');
+        return {
+            isNpm: false,
+            isPnpm: false,
+            isYarn: true,
+        };
+    }
+    const packageManager = mapping.get(filePaths[0]);
+    return {
+        isNpm: packageManager === 'npm',
+        isPnpm: packageManager === 'pnpm',
+        isYarn: packageManager === 'yarn',
+    };
+}
+function deriveAddonLocation(addonPackage) {
+    const hasScope = addonPackage.name.includes('/');
+    if (!hasScope) {
+        return addonPackage.name;
+    }
+    // eslint-disable-next-line no-unused-vars
+    const [_scope, packageName] = addonPackage.name.split('/');
+    return packageName;
+}
+export function createOptions(codemodOptions) {
+    const addonPackage = analyzePackageJson(codemodOptions);
+    const packageManager = analyzePackageManager(codemodOptions);
+    return {
+        locations: {
+            addon: codemodOptions.addonLocation ?? deriveAddonLocation(addonPackage),
+            testApp: codemodOptions.testAppLocation ?? 'test-app',
+        },
+        packageManager,
+        packages: {
+            addon: addonPackage,
+            testApp: {
+                name: codemodOptions.testAppName ?? 'test-app',
+            },
+        },
+        projectRoot: codemodOptions.projectRoot,
+    };
+}

package/dist/src/migration/ember-addon/steps/move-addon-files.js

@@ -0,0 +1,59 @@
+import { findFiles, mapFilePaths, moveFiles, removeFiles, } from '@codemod-utils/files';
+function moveAddonFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('addon/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'addon',
+        to: `${locations.addon}/src`,
+    });
+    moveFiles(filePathMap, options);
+}
+function moveAddonTestSupportFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('addon-test-support/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'addon-test-support',
+        to: `${locations.addon}/src/test-support`,
+    });
+    moveFiles(filePathMap, options);
+}
+function moveBlueprintsFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('blueprints/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'blueprints',
+        to: `${locations.addon}/blueprints`,
+    });
+    moveFiles(filePathMap, options);
+}
+function movePublicFolder(options) {
+    const { locations, projectRoot } = options;
+    const filePaths = findFiles('public/**/*', {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: 'public',
+        to: `${locations.addon}/public`,
+    });
+    moveFiles(filePathMap, options);
+}
+function removeAppFolder(options) {
+    const { projectRoot } = options;
+    const filePaths = findFiles('app/**/*', {
+        projectRoot,
+    });
+    removeFiles(filePaths, options);
+}
+export function moveAddonFiles(options) {
+    moveAddonFolder(options);
+    moveAddonTestSupportFolder(options);
+    moveBlueprintsFolder(options);
+    movePublicFolder(options);
+    removeAppFolder(options);
+}

package/dist/src/migration/ember-addon/steps/move-project-root-files.js

@@ -0,0 +1,79 @@
+import { copyFiles, findFiles, mapFilePaths, moveFiles, removeFiles, unionize, } from '@codemod-utils/files';
+function copyToAddon(options) {
+    const { locations, projectRoot } = options;
+    const files = ['LICENSE.md', 'README.md'];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.addon,
+    });
+    copyFiles(filePathMap, options);
+}
+function moveToAddonAndTestApp(options) {
+    const { locations, packages, projectRoot } = options;
+    const files = new Set([
+        '.eslintignore',
+        '.eslintrc.cjs',
+        '.eslintrc.js',
+        '.gitignore',
+        '.prettierignore',
+        '.prettierrc.cjs',
+        '.prettierrc.js',
+        '.stylelintignore',
+        '.stylelintrc.cjs',
+        '.stylelintrc.js',
+        '.template-lintrc.cjs',
+        '.template-lintrc.js',
+        'package.json',
+    ]);
+    if (packages.addon.hasTypeScript) {
+        files.add('tsconfig.json');
+    }
+    const filePaths = findFiles(unionize([...files]), {
+        projectRoot,
+    });
+    let filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.addon,
+    });
+    copyFiles(filePathMap, options);
+    filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.testApp,
+    });
+    copyFiles(filePathMap, options);
+    removeFiles(filePaths, options);
+}
+function moveToTestApp(options) {
+    const { locations, projectRoot } = options;
+    const files = [
+        '.ember-cli',
+        '.watchmanconfig',
+        'ember-cli-build.js',
+        'testem.js',
+    ];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    const filePathMap = mapFilePaths(filePaths, {
+        from: '',
+        to: locations.testApp,
+    });
+    moveFiles(filePathMap, options);
+}
+function removeFromProjectRoot(options) {
+    const { projectRoot } = options;
+    const files = ['.npmignore', 'index.js'];
+    const filePaths = findFiles(unionize(files), {
+        projectRoot,
+    });
+    removeFiles(filePaths, options);
+}
+export function moveProjectRootFiles(options) {
+    copyToAddon(options);
+    moveToAddonAndTestApp(options);
+    moveToTestApp(options);
+    removeFromProjectRoot(options);
+}