create-lwr 0.6.0 → 0.6.4

package/build/es/index.js

@@ -2,9 +2,7 @@
 import fs from 'fs';
 import path from 'path';
 import minimist from 'minimist';
-import { green, blue, red } from 'kolorist';
-import prompts from 'prompts';
-import { isEmpty, isValidPackageName, toValidPackageName, emptyDir, copy, pkgFromUserAgent, } from './utils.js';
+import { emptyDir, copy, pkgFromUserAgent, promptForAnswers, updateLwrVersion } from './utils.js';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -13,144 +11,73 @@ const argv = minimist(process.argv.slice(2), { string: ['_'] });
 const renameFiles = {
     _gitignore: '.gitignore',
 };
-const PROJECTS = [
-    {
-        name: 'Static Site',
-        color: green,
-        variants: [
-            {
-                name: 'markdown-static-site',
-                display: 'Markdown Static Site',
-                color: green,
-            },
-        ],
-    },
-    {
-        name: 'Single Page App',
-        color: green,
-        variants: [
-            {
-                name: 'lwc',
-                display: 'LWC',
-                color: green,
-            },
-            {
-                name: 'lwc-ts',
-                display: 'LWC (TypeScript)',
-                color: blue,
-            },
-        ],
-    },
-];
-const TEMPLATES = PROJECTS.map((f) => (f.variants && f.variants.map((v) => v.name)) || [f.name]).reduce((a, b) => a.concat(b), []);
 export async function init() {
-    let targetDir = argv._[0];
-    let template = argv.template || argv.t;
-    const defaultProjectName = !targetDir ? 'lwr-project' : targetDir;
-    let result = {};
+    const targetDir = argv._[0];
+    const metadata = {
+        targetDir,
+        template: argv.template || argv.t,
+        defaultProjectName: !targetDir ? 'lwr-project' : targetDir,
+    };
+    let userFeedback = {};
     try {
-        result = await prompts([
-            {
-                type: targetDir ? null : 'text',
-                name: 'projectName',
-                message: 'Project name:',
-                initial: defaultProjectName,
-                onState: (state) => (targetDir = state.value.trim() || defaultProjectName),
-            },
-            {
-                type: () => (!fs.existsSync(targetDir) || isEmpty(targetDir) ? null : 'confirm'),
-                name: 'overwrite',
-                message: () => (targetDir === '.' ? 'Current directory' : `Target directory "${targetDir}"`) +
-                    ` is not empty. Remove existing files and continue?`,
-            },
-            {
-                type: (_, { overwrite } = {}) => {
-                    if (overwrite === false) {
-                        throw new Error(red('✖') + ' Operation cancelled');
-                    }
-                    return null;
-                },
-                name: 'overwriteChecker',
-            },
-            {
-                type: () => (isValidPackageName(targetDir) ? null : 'text'),
-                name: 'packageName',
-                message: 'Package name:',
-                initial: () => toValidPackageName(targetDir),
-                validate: (dir) => isValidPackageName(dir) || 'Invalid package.json name',
-            },
-            {
-                type: template && TEMPLATES.includes(template) ? null : 'select',
-                name: 'projectType',
-                message: typeof template === 'string' && !TEMPLATES.includes(template)
-                    ? `"${template}" isn't a valid template. Please choose from below: `
-                    : 'Select a type of project:',
-                initial: 0,
-                choices: PROJECTS.map((project_type) => {
-                    const frameworkColor = project_type.color;
-                    return {
-                        title: frameworkColor(project_type.name),
-                        value: project_type,
-                    };
-                }),
-            },
-            {
-                type: (project_type) => project_type && project_type.variants ? 'select' : null,
-                name: 'variant',
-                message: 'Select a variant:',
-                choices: (project_type) => project_type.variants.map((variant) => {
-                    const variantColor = variant.color;
-                    return {
-                        title: variantColor(variant.display || variant.name),
-                        value: variant.name,
-                    };
-                }),
-            },
-        ], {
-            onCancel: () => {
-                throw new Error(red('✖') + ' Operation cancelled');
-            },
-        });
+        userFeedback = await promptForAnswers(metadata);
     }
     catch (cancelled) {
         console.log(cancelled.message);
         return;
     }
-    // user choice associated with prompts
-    const { projectType, overwrite, packageName, variant } = result;
-    const root = path.join(cwd, targetDir);
+    const { results: { overwrite, packageName, template }, } = userFeedback;
+    const { metadata: revisedMetadata } = userFeedback;
+    const projectRoot = path.join(cwd, revisedMetadata.targetDir);
+    createRootDir(projectRoot, revisedMetadata, overwrite, template);
+    const templateDir = path.join(__dirname, '../../', `template-${revisedMetadata.template}`);
+    writeFiles(projectRoot, templateDir);
+    const pkgManager = writePackageFile(projectRoot, templateDir, packageName, revisedMetadata);
+    logResult(projectRoot, pkgManager);
+}
+function createRootDir(projectRoot, metadata, overwrite, template) {
     if (overwrite) {
-        emptyDir(root);
+        emptyDir(projectRoot);
     }
-    else if (!fs.existsSync(root)) {
-        fs.mkdirSync(root);
+    else if (!fs.existsSync(projectRoot)) {
+        fs.mkdirSync(projectRoot, { recursive: true });
     }
     // determine template
-    template = variant || projectType || template;
-    console.log(`\nScaffolding project in ${root}...`);
-    const templateDir = path.join(__dirname, '../../', `template-${template}`);
-    const write = (file, content) => {
-        const targetPath = renameFiles[file] ? path.join(root, renameFiles[file]) : path.join(root, file);
-        if (content) {
-            fs.writeFileSync(targetPath, content);
-        }
-        else {
-            copy(path.join(templateDir, file), targetPath);
-        }
-    };
+    metadata.template = template || metadata.template;
+    console.log(`\nScaffolding project in ${projectRoot}...`);
+}
+const write = (projectRoot, templateDir, file, content) => {
+    const targetPath = renameFiles[file]
+        ? path.join(projectRoot, renameFiles[file])
+        : path.join(projectRoot, file);
+    if (content) {
+        fs.writeFileSync(targetPath, content);
+    }
+    else {
+        copy(path.join(templateDir, file), targetPath);
+    }
+};
+function writeFiles(projectRoot, templateDir) {
     const files = fs.readdirSync(templateDir);
     for (const file of files.filter((f) => f !== 'package.json')) {
-        write(file);
+        write(projectRoot, templateDir, file);
     }
+}
+function writePackageFile(projectRoot, templateDir, packageName, metadata) {
     // modify package json name
     const pkg = JSON.parse(fs.readFileSync(path.join(templateDir, `package.json`), 'utf-8'));
-    pkg.name = packageName || targetDir;
-    write('package.json', JSON.stringify(pkg, null, 2));
+    pkg.name = packageName || metadata.targetDir;
+    // Set the target lwr package version equal to this create-lwr package version
+    updateLwrVersion(templateDir, pkg);
+    write(projectRoot, templateDir, 'package.json', JSON.stringify(pkg, null, 2));
     const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
     const pkgManager = pkgInfo ? pkgInfo.name : 'npm';
+    return pkgManager;
+}
+function logResult(projectRoot, pkgManager) {
     console.log(`\nDone. Now run:\n`);
-    if (root !== cwd) {
-        console.log(`  cd ${path.relative(cwd, root)}`);
+    if (projectRoot !== cwd) {
+        console.log(`  cd ${path.relative(cwd, projectRoot)}`);
     }
     switch (pkgManager) {
         case 'yarn':

package/build/es/types.d.ts

@@ -0,0 +1,26 @@
+export interface ProjectTemplate {
+    name: string;
+    display: string;
+    color: any;
+}
+export interface ProjectType {
+    name: string;
+    color: any;
+    templates: ProjectTemplate[];
+}
+export interface ProjectMetadata {
+    targetDir?: string;
+    template?: string;
+    defaultProjectName: string;
+}
+export declare type NormalizedProjectMetadata = Required<ProjectMetadata>;
+export interface Answers {
+    overwrite: boolean;
+    packageName: string;
+    template: string;
+}
+export interface AnswersWithMetadata {
+    results: Answers;
+    metadata: NormalizedProjectMetadata;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/es/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/es/utils.d.ts

@@ -1,11 +1,15 @@
-export declare function isEmpty(path: string): boolean;
-export declare function isValidPackageName(projectName: string): boolean;
-export declare function toValidPackageName(projectName: string): string;
+import { AnswersWithMetadata, ProjectType, ProjectMetadata } from './types';
+export declare const PROJECTS: ProjectType[];
 export declare function emptyDir(dir: string): void;
 export declare function copy(src: string, dest: string): void;
-export declare function copyDir(srcDir: string, destDir: string): void;
 export declare function pkgFromUserAgent(userAgent: string | undefined): {
     name: string;
     version: string;
 } | undefined;
+export declare function updateLwrVersion(templateDir: string, pkg: {
+    dependencies?: {
+        lwr?: string;
+    };
+}): void;
+export declare function promptForAnswers(metadata: ProjectMetadata): Promise<AnswersWithMetadata>;
 //# sourceMappingURL=utils.d.ts.map

package/build/es/utils.js

@@ -1,12 +1,44 @@
 import fs from 'fs';
 import path from 'path';
-export function isEmpty(path) {
+import { red, green, blue } from 'kolorist';
+import prompts from 'prompts';
+export const PROJECTS = [
+    {
+        name: 'Static Site',
+        color: green,
+        templates: [
+            {
+                name: 'markdown-static-site',
+                display: 'Markdown Static Site',
+                color: green,
+            },
+        ],
+    },
+    {
+        name: 'Single Page App',
+        color: green,
+        templates: [
+            {
+                name: 'lwc',
+                display: 'LWC',
+                color: green,
+            },
+            {
+                name: 'lwc-ts',
+                display: 'LWC (TypeScript)',
+                color: blue,
+            },
+        ],
+    },
+];
+const TEMPLATES = PROJECTS.map((t) => (t.templates && t.templates.map((t) => t.name)) || [t.name]).reduce((a, b) => a.concat(b), []);
+function isDirEmpty(path) {
     return fs.readdirSync(path).length === 0;
 }
-export function isValidPackageName(projectName) {
+function isValidPackageName(projectName) {
     return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(projectName);
 }
-export function toValidPackageName(projectName) {
+function toValidPackageName(projectName) {
     return projectName
         .trim()
         .toLowerCase()
@@ -14,15 +46,17 @@ export function toValidPackageName(projectName) {
         .replace(/^[._]/, '')
         .replace(/[^a-z0-9-~]+/g, '-');
 }
+// Recursively empty the given directory
 export function emptyDir(dir) {
     if (!fs.existsSync(dir)) {
         return;
     }
     for (const file of fs.readdirSync(dir)) {
         const abs = path.resolve(dir, file);
-        fs.rmSync(abs);
+        fs.rmSync(abs, { recursive: true, force: true });
     }
 }
+// Copy a directory or file to a new destination
 export function copy(src, dest) {
     const stat = fs.statSync(src);
     if (stat.isDirectory()) {
@@ -32,7 +66,8 @@ export function copy(src, dest) {
         fs.copyFileSync(src, dest);
     }
 }
-export function copyDir(srcDir, destDir) {
+/* istanbul ignore next */
+function copyDir(srcDir, destDir) {
     fs.mkdirSync(destDir, { recursive: true });
     for (const file of fs.readdirSync(srcDir)) {
         const srcFile = path.resolve(srcDir, file);
@@ -50,4 +85,93 @@ export function pkgFromUserAgent(userAgent) {
         version: pkgSpecArr[1],
     };
 }
+export function updateLwrVersion(templateDir, pkg) {
+    const createLwrPkg = JSON.parse(fs.readFileSync(path.join(templateDir, `../package.json`), 'utf-8'));
+    const version = createLwrPkg.version;
+    if (!pkg.dependencies) {
+        pkg.dependencies = { lwr: version };
+    }
+    else {
+        pkg.dependencies.lwr = version;
+    }
+}
+// Gather project information from the user in the terminal
+export async function promptForAnswers(metadata) {
+    const results = await prompts([
+        {
+            // Get the project name, used as the LWR project directory and saved as metadata.targetDir
+            type: metadata.targetDir ? null : 'text',
+            name: 'projectName',
+            message: 'Project directory name:',
+            initial: metadata.defaultProjectName,
+            onState: (state) => (metadata.targetDir = state.value.trim() || metadata.defaultProjectName),
+        },
+        {
+            // If the targetDir is not empty, ask if the current contents should be deleted (i.e. overwritten)
+            type: () => !fs.existsSync(metadata.targetDir) || isDirEmpty(metadata.targetDir)
+                ? null
+                : 'confirm',
+            name: 'overwrite',
+            message: () => (metadata.targetDir === '.'
+                ? 'Current directory'
+                : `Target directory "${metadata.targetDir}"`) +
+                ` is not empty. Remove existing files and continue?`,
+        },
+        {
+            // If the current contents SHOULD NOT be overwritten, throw an error and exit
+            type: (_, { overwrite } = {}) => {
+                if (overwrite === false) {
+                    throw new Error(red('✖') + ' Operation cancelled');
+                }
+                return null;
+            },
+            name: 'overwriteChecker',
+        },
+        {
+            // If the projectName/targetDir is not a valid package.json[name], prompt for a new one
+            type: () => (isValidPackageName(metadata.targetDir) ? null : 'text'),
+            name: 'packageName',
+            message: 'Package name (used in package.json):',
+            initial: () => toValidPackageName(metadata.targetDir),
+            validate: (dir) => isValidPackageName(dir) || 'Invalid package.json name',
+        },
+        {
+            // Select a project type, if the user has not passed in a "--template"
+            type: metadata.template && TEMPLATES.includes(metadata.template) ? null : 'select',
+            name: 'projectType',
+            message: typeof metadata.template === 'string' && !TEMPLATES.includes(metadata.template)
+                ? `"${metadata.template}" isn't a valid template. Please choose from below: `
+                : 'Select the type of project:',
+            initial: 0,
+            choices: PROJECTS.map((project_type) => {
+                const frameworkColor = project_type.color;
+                return {
+                    title: frameworkColor(project_type.name),
+                    value: project_type,
+                };
+            }),
+        },
+        {
+            // If the user picked a project type (i.e. "project_type") in the previous prompt, now choose a template
+            type: (project_type) => (project_type && project_type.templates ? 'select' : null),
+            name: 'template',
+            message: 'Select a project template:',
+            choices: (project_type) => project_type.templates.map((template) => {
+                const templateColor = template.color;
+                return {
+                    title: templateColor(template.display || template.name),
+                    value: template.name,
+                };
+            }),
+        },
+    ], {
+        onCancel: () => {
+            throw new Error(red('✖') + ' Operation cancelled');
+        },
+    });
+    return {
+        results,
+        metadata: metadata, // possible mutation of metadata in prompts
+    };
+}
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -10,7 +10,7 @@
         "url": "https://github.com/salesforce/lwr/issues"
     },
     "bin": {
-        "create-lwc": "build/es/index.js"
+        "create-lwr": "build/es/index.js"
     },
     "scripts": {
         "local:bin": "node ./build/es/index.js"
@@ -21,7 +21,7 @@
     },
     "type": "module",
     "types": "build/es/index.d.ts",
-    "version": "0.6.0",
+    "version": "0.6.4",
     "module": "build/es/index.js",
     "main": "build/cjs/index.cjs",
     "files": [
@@ -39,5 +39,5 @@
         "minimist": "^1.2.5",
         "prompts": "^2.4.1"
     },
-    "gitHead": "31769655f0155ad7e54cf37bccdf72d0baaf44ab"
+    "gitHead": "80b73fe4558dc3db0afcdbe80eb17f5a1464e34e"
 }

package/template-lwc/package.json

@@ -13,7 +13,7 @@
     },
     "dependencies": {
         "lwc": "2.5.8",
-        "lwr": "0.6.0-alpha.14"
+        "lwr": "0.6.1"
     },
     "engines": {
         "node": ">=14.15.4 <17"

package/template-lwc-ts/package.json

@@ -13,7 +13,7 @@
     },
     "dependencies": {
         "lwc": "2.5.8",
-        "lwr": "0.6.0-alpha.14"
+        "lwr": "0.6.1"
     },
     "engines": {
         "node": ">=14.15.4 <17"

package/template-markdown-static-site/package.json

@@ -13,7 +13,7 @@
     },
     "dependencies": {
         "lwc": "2.5.8",
-        "lwr": "0.6.0-alpha.14"
+        "lwr": "0.6.1"
     },
     "engines": {
         "node": ">=14.15.4 <17"