@reactful/create 0.0.94 → 0.0.96

package/index.js

@@ -1,12 +1,10 @@
 #!/usr/bin/env node
 
-
+import npmRegistryFetch from 'npm-registry-fetch'
 import { execSync } from 'child_process'
-import npmPackage from 'npm-package-arg'
-import npmDownload from 'npm-download'
 import inquirer from 'inquirer'
-import fetch from 'node-fetch'
 import path from 'path'
+import * as tar from 'tar'
 import fs from 'fs'
 
 const GREEN = '\x1b[32m'
@@ -21,36 +19,43 @@ console.log(line)
 
 const templates = ['empty', 'minimal', 'sampling']
 
-const questions = [
-   {
-      type: 'list',
-      name: 'template',
-      message: 'Which template?',
-      choices: templates,
-      prefix
-   },
-   { type: 'input', name: 'project', message: 'Project name?', prefix },
-   { type: 'confirm', name: 'vscode', message: 'VS Code IDE?', prefix },
-   { type: 'confirm', name: 'install', message: 'Install?', prefix },
+const questions = [{
+   type: 'list',
+   name: 'template',
+   message: 'Which template?',
+   choices: templates,
+   prefix
+},
+{ type: 'input', name: 'project', message: 'Project name?', prefix, default: 'Sample' },
+{ type: 'confirm', name: 'vscode', message: 'VS Code IDE?', prefix },
+{ type: 'confirm', name: 'install', message: 'Install?', prefix },
 ]
 
-inquirer.prompt(questions).then(async function (answers) {
-   fs.mkdirSync(answers.project)
-   
+inquirer.prompt(questions).then(prompting)
+
+async function prompting(answers) {
+   if (!answers.project) throw 'Required project name!'
+
    const destination = path.join(process.cwd(), answers.project)
-   
-   await download(`commons`, destination)
-   await download(`templates/${answers.template}`, destination)
-   
+   const temporaryPath = path.join(destination, 'temp')
+
+   await createDirectory(destination)
+
+   console.log('- downloading package...')
+   await download('@reactful/create', temporaryPath)
+
+   console.log('- copying template...')
+   await copyTemplate(temporaryPath, `commons`, destination)
+   await copyTemplate(temporaryPath, `templates/${answers.template}`, destination)
+   await removeDirectory(temporaryPath)
+
    console.log('- templating project...')
    renamingJSON(destination, answers.project)
 
-   
-   console.log('- installing dependencies...')   
-   console.log('')
+   console.log('- installing dependencies...\n')
    execSync(`cd ${answers.project}`)
    execSync(`bun install`)
-})
+}
 
 function renamingJSON(directory, projectName) {
    const url = `${directory}/package.json`
@@ -62,70 +67,69 @@ function renamingJSON(directory, projectName) {
    fs.writeFileSync(url, JSON.stringify(obj, null, 3))
 }
 
-const download = async (subfolder, destination) =>
-   downloadNPM('@reactful/create', subfolder, destination)
-
-async function downloadNPM(packageName, subdirectory, destination) {
+async function copyTemplate(temporaryPath, subdirectory, destination) {
    try {
-       const pkg = npmPackage.resolve(packageName)
-       const content = await npmDownload(pkg, { dir: 'temp' })
-       const from = path.join(content, subdirectory, destination)
-       const notFound = fs.existsSync(destination) == false
+      const folder = path.join(temporaryPath, subdirectory)
+      await copyFolder(folder, destination)
 
-       if (notFound) fs.mkdirSync(destination, { recursive: true })
-
-       fs.renameSync(from, destination)
    } catch (error) {
-       console.error('Download NPM:', error)
+      console.error('copyTemplate')
+      throw error
    }
 }
 
-async function downloadGitHub(user, repository, subdir, destination) {
-   console.log(`- downloading ${subdir}...`)
+async function download(packageName, directory) {
+   try {
+      await createDirectory(directory)
 
-   const prefix = `https://api.github.com/repos/${user}/${repository}`
-   const address = `${prefix}/contents/installation/${subdir}`
-   const response = await fetch(address) 
-   const contents = await response.json()
+      const metadata = await npmRegistryFetch.json(packageName)
+      const latestVersion = metadata['dist-tags'].latest
+      const tarballURL = metadata.versions[latestVersion].dist.tarball
+      const filename = tarballURL.substring(tarballURL.lastIndexOf('/') + 1)
+      const tempFilePath = path.join(directory, filename)
 
-   if (!Array.isArray(contents) || !response.ok) {
-      console.log('moment: DIRECTORY...')
-      logging(response, contents)
-      throw 'failed to download scafold from github...'
-   }
+      if (!fs.existsSync(directory))
+         fs.mkdirSync(directory, { recursive: true })
 
-   for (const item of contents) {
-      if (item.type === 'dir' && item.name) {
-         const from = `${subdir}/${item.name}`
-         const goto = `${destination}/${item.name}`   
-         await download(from, goto); continue
-      }
-
-      if (item.type != 'file') continue
-      
-      try {
-         const filePath = path.join(destination, item.name)
-         const response = await fetch(item.download_url)
-         const fileText = await response.text()
-         const baseFile = path.dirname(filePath)
-         const notFound = fs.existsSync(baseFile) == false
-
-         if (notFound) fs.mkdirSync(baseFile, { recursive: true })
-
-         fs.writeFileSync(filePath, fileText)
-      }
-      catch(ex) {
-         console.log('MOMMENT: file...')
-         logging(response, contents, item.download_url)
-         throw ex
-      }
+      const response = await npmRegistryFetch(tarballURL)
+
+      await new Promise((resolve, reject) => {
+         const fileStream = fs.createWriteStream(tempFilePath)
+         response.body.pipe(fileStream)
+         response.body.on('error', reject)
+         fileStream.on('finish', resolve)
+      })
+
+      await tar.x({ file: tempFilePath, cwd: directory, strip: 1 })
+
+      fs.unlinkSync(tempFilePath)
+   } catch (error) {
+      console.error('downloadPackage')
+      throw error
    }
 }
 
-function logging(response, contents, download) {
-   console.log('url: ', response.url)
-   console.log('code: ', response.status)
-   console.log('array: ', Array.isArray(contents))
-   console.log('textual: ', JSON.stringify(contents))
-   console.log('download: ', item.download_url)
+
+function createDirectory(directory) {
+   removeDirectory(directory)
+   fs.mkdirSync(directory)
+}
+
+function removeDirectory(directory) {
+   if (!fs.existsSync(directory)) return
+   else fs.rmSync(directory, { recursive: true })
+}
+
+function copyFolder(source, target) {
+   if (!fs.existsSync(target)) fs.mkdirSync(target)
+
+   fs.readdirSync(source).forEach(function (file) {
+      const currentPath = path.join(source, file)
+      const targetPath = path.join(target, file)
+
+      if (fs.lstatSync(currentPath).isDirectory())
+         copyFolder(currentPath, targetPath)
+
+      else fs.copyFileSync(currentPath, targetPath)
+   })
 }

package/package.json

@@ -1,20 +1,26 @@
 {
   "name": "@reactful/create",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "main": "index.js",
   "type": "module",
   "description": "reactful scafold tool",
   "author": "jonathan de sena ribeiro <jsenaribeiro@gmail.com>",
-  "files": ["index.js", "package.json", "templates", "commons"],
   "bin": { "@reactful/create": "index.js" },
-  "scripts": { "deploy": "npm publish --access public" },
+  "files": [
+    "index.js",
+    "package.json",
+    "templates",
+    "commons"
+  ],
+  "scripts": {
+    "start": "bun run index.js",
+    "deploy": "npm publish --access public"
+  },
   "license": "MIT",
   "dependencies": {
     "bun-types": "latest",
-    "fs": "^0.0.1-security",
     "inquirer": "^9.2.13",
-    "node-fetch": "^3.3.2",
-    "npm-download": "^2.0.0",
-    "npm-package-arg": "^11.0.1"
+    "npm-registry-fetch": "^16.1.0",
+    "tar": "^6.2.0"
   }
-}
+}