create-quasar 2.2.2 → 4.0.0

package/{templates/ui-kit/quasar-v2/BASE/LICENSE → LICENSE}

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) <%= scope.author %>
+Copyright (c) 2015-present Razvan Stoenescu
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/bin/create-quasar.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+import { join } from 'node:path'
+import { parseArgs } from 'node:util'
+
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  const { cliPkg } = await import('../lib/cli-pkg.js')
+  console.log(cliPkg.version)
+  process.exit(0)
+}
+
+if (
+  process.argv.includes('--no-color') ||
+  (await import('ci-info').then(({ isCI }) => isCI))
+) {
+  process.env.FORCE_COLOR = '0'
+}
+
+const { cliPkg } = await import('../lib/cli-pkg.js')
+const { showCliBanner } = await import('@quasar/art')
+
+const { runningPackageManager } = await import('../lib/running-pm.js')
+if (!runningPackageManager) {
+  const { default: updateNotifier } = await import('update-notifier')
+  updateNotifier({ pkg: cliPkg }).notify()
+}
+
+showCliBanner()
+
+function showHelp(warn) {
+  const cmdMap = {
+    pnpm: 'pnpm create quasar@latest',
+    yarn: 'yarn create quasar',
+    npm: 'npm init quasar@latest',
+    bun: 'bun create quasar@latest'
+  }
+  const createCommand = cmdMap[runningPackageManager] || 'create-quasar'
+
+  console.log(`
+  Description
+    Scaffolds Quasar Apps & App Extensions
+    Version ${cliPkg.version}
+
+  Usage
+    $ ${createCommand} [dir] [options]
+
+    # examples:
+    $ ${createCommand} my-app --template app --engine vite-3 --defaults
+    $ ${createCommand} my-ae --template ae --preset prompts --preset oxlint --defaults
+
+  Options
+    --template, -t  Type of project to create: app | ae
+    --overwrite, -o Overwrite existing dir if it exists
+    --preset        Preset to apply (can be used multiple times)
+                    - template "app" presets:
+                      typescript, sass, oxlint, eslint, i18n, pinia, fbr (filename-based routing)
+                    - template "ae" presets:
+                      typescript, oxlint, prompts, install, uninstall
+    --name          Name of the project for package.json (must be a valid npm package name)
+    --author        Author name for package.json
+    --no-git        Do not initialize a git repository
+    --install, -i   When invoked through a package manager it's a boolean (eg. --install)
+                    Otherwise, the package manager to auto-install with:
+                      --install pnpm
+                      --install yarn
+                      --install npm
+                      --install bun
+
+    --engine, -e    (ONLY for template "app") Quasar App Local CLI to use
+                      Please note that these do NOT refer to the version of
+                      Vite, but rather to the @quasar/app-vite version to use:
+                        vite-3 or vite-2
+    --product       (ONLY for template "app") Product name for the app
+
+    --defaults, -d  Use default values for the remaining non-specified options
+    --no-color      Disable colored output
+    --help, -h      Displays this message
+  `)
+
+  warn?.()
+  process.exit(0)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  showHelp()
+}
+
+const { isInsideQuasarProject } =
+  await import('../lib/ensure-outside-project.js')
+
+if (isInsideQuasarProject()) {
+  console.error(
+    'Error ⚠️  This command must NOT be executed inside of a Quasar project folder.'
+  )
+  process.exit(1)
+}
+
+function argvError(errorMessage) {
+  return {
+    help: true,
+    __warn() {
+      console.error('Error ⚠️  ' + errorMessage)
+      console.log()
+      process.exit(1)
+    }
+  }
+}
+
+async function getArgv() {
+  let scope, positionals
+
+  try {
+    const { values, positionals: pos } = parseArgs({
+      options: {
+        'no-git': { type: 'boolean' },
+        overwrite: { type: 'boolean', short: 'o' },
+        template: { type: 'string', short: 't' },
+        engine: { type: 'string', short: 'e' },
+        preset: { type: 'string', short: 'p', multiple: true },
+        linter: { type: 'string', short: 'l' },
+        name: { type: 'string' },
+        product: { type: 'string' },
+        author: { type: 'string' },
+        install: runningPackageManager
+          ? { type: 'boolean', short: 'i' }
+          : { type: 'string', short: 'i' },
+
+        defaults: { type: 'boolean', short: 'd' },
+        'no-color': { type: 'boolean' },
+        help: { type: 'boolean', short: 'h' }
+      },
+      strict: true,
+      allowPositionals: true
+    })
+
+    scope = values
+    positionals = pos
+  } catch (err) {
+    return argvError(
+      err?.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION'
+        ? err.message
+        : 'Unknown error while parsing arguments'
+    )
+  }
+
+  if (positionals.length > 1) {
+    return argvError(
+      'Too many positional arguments provided (only one is allowed): ' +
+        positionals.join(', ')
+    )
+  }
+
+  const { default: utils } = await import('../lib/utils.js')
+  if (scope.defaults) {
+    if (scope.overwrite === void 0) scope.overwrite = true
+    if (!scope.template) {
+      scope.template = utils.definitions.template.default
+    }
+  }
+
+  const { template } = scope
+  const packageManagerList = ['pnpm', 'yarn', 'npm', 'bun']
+  scope.packageManagerList = runningPackageManager
+    ? [runningPackageManager]
+    : packageManagerList
+
+  if (template) {
+    if (template === 'ae') {
+      if (scope.engine) {
+        return argvError(
+          'The --engine option is not applicable for template "ae". Please remove it.'
+        )
+      }
+      if (scope.product) {
+        return argvError(
+          'The --product option is not applicable for template "ae". Please remove it.'
+        )
+      }
+
+      if (scope.defaults) {
+        if (scope.install === void 0) scope.install = 'pnpm'
+        if (!scope.preset) {
+          scope.preset = ['prompts', 'install', 'uninstall', 'oxlint']
+        }
+      }
+      const { preset, install } = scope
+
+      if (install) {
+        if (runningPackageManager) {
+          if (runningPackageManager !== 'pnpm') {
+            return argvError(
+              `Package manager ${runningPackageManager} is not allowed with --install. Use only "pnpm".`
+            )
+          }
+
+          scope.install = runningPackageManager
+        } else if (install !== 'pnpm') {
+          return argvError(
+            'Invalid package manager specified with --install for App Extension: ' +
+              install +
+              '. Allowed value is "pnpm".'
+          )
+        }
+      }
+
+      if (preset) {
+        const opts = ['prompts', 'install', 'uninstall', 'oxlint', 'typescript']
+        if (preset.some(p => !opts.includes(p))) {
+          return argvError(
+            'Invalid preset specified: ' +
+              preset.join(', ') +
+              '. Allowed values are "prompts", "install", "uninstall", "oxlint", "typescript".'
+          )
+        }
+
+        if (preset.includes('oxlint')) {
+          scope.preset = preset.filter(p => p !== 'oxlint')
+          scope.preset.push('linting')
+          scope.linter = 'oxlint'
+        }
+      }
+    } else if (template === 'app') {
+      if (scope.defaults) {
+        if (scope.install === void 0) scope.install = 'pnpm'
+        if (!scope.engine) scope.engine = utils.definitions.engine.default
+      }
+      const { engine, install } = scope
+
+      if (install) {
+        if (runningPackageManager) {
+          if (!packageManagerList.includes(runningPackageManager)) {
+            return argvError(
+              `Package manager ${runningPackageManager} is not allowed with --install. Allowed package managers are ${packageManagerList.join(
+                ', '
+              )}.`
+            )
+          }
+
+          scope.install = runningPackageManager
+        } else if (!packageManagerList.includes(install)) {
+          return argvError(
+            'Invalid package manager specified with --install: ' +
+              install +
+              '. Allowed values are ' +
+              packageManagerList.join(', ') +
+              '.'
+          )
+        }
+      }
+
+      if (engine) {
+        if (scope.defaults && !scope.product) {
+          scope.product = utils.definitions.product.default
+        }
+
+        if (engine === 'vite-3') {
+          if (scope.defaults && !scope.preset) {
+            scope.preset = ['sass', 'oxlint']
+          }
+          const { preset } = scope
+
+          if (preset) {
+            const opts = [
+              'typescript',
+              'sass',
+              'oxlint',
+              'eslint',
+              'fbr',
+              'i18n',
+              'pinia'
+            ]
+
+            if (preset.some(p => !opts.includes(p))) {
+              return argvError(
+                'Invalid preset specified: ' +
+                  preset.join(', ') +
+                  '. Allowed values are "typescript", "sass", "oxlint", "eslint", "fbr", "i18n", "pinia".'
+              )
+            }
+
+            const hasOxlint = preset.includes('oxlint')
+            const hasEslint = preset.includes('eslint')
+
+            if (hasOxlint && hasEslint) {
+              return argvError(
+                'Invalid presets specified: oxlint and eslint cannot be used together. Please choose one of them.'
+              )
+            }
+
+            if (hasOxlint) {
+              scope.preset = preset.filter(p => p !== 'oxlint')
+              scope.preset.push('linting')
+              scope.linter = 'oxlint'
+            } else if (hasEslint) {
+              scope.preset = preset.filter(p => p !== 'eslint')
+              scope.preset.push('linting')
+              scope.linter = 'eslint'
+            }
+          }
+        } else if (engine === 'vite-2') {
+          if (scope.defaults && !scope.preset) {
+            scope.preset = ['sass', 'eslint']
+          }
+          const { preset } = scope
+
+          if (preset) {
+            const opts = ['typescript', 'sass', 'eslint', 'i18n', 'pinia']
+            if (preset.some(p => !opts.includes(p))) {
+              return argvError(
+                'Invalid preset specified: ' +
+                  preset.join(', ') +
+                  '. Allowed values are "typescript", "sass", "eslint", "i18n", "pinia".'
+              )
+            }
+
+            if (preset.includes('eslint')) {
+              scope.preset = preset.filter(p => p !== 'eslint')
+              scope.preset.push('linting')
+              scope.linter = 'eslint'
+            }
+          }
+        } else {
+          return argvError(
+            'Invalid engine specified: ' +
+              engine +
+              '. Allowed values are "vite-3" and "vite-2".'
+          )
+        }
+      }
+    } else {
+      return argvError(
+        'Invalid template specified: ' +
+          template +
+          '. Allowed values are "app" and "ae".'
+      )
+    }
+  }
+
+  if (!scope.author) scope.author = await utils.getGitUser()
+
+  const dir =
+    positionals[0]?.trim() ||
+    (scope.defaults && utils.definitions.projectFolder.default)
+
+  if (dir) {
+    scope.projectFolder = join(process.cwd(), dir)
+    scope.projectFolderName = dir
+
+    if (!scope.name) scope.name = utils.definitions.name.default(dir)
+  }
+
+  if (scope.name && !utils.definitions.name.isValid(scope.name)) {
+    return argvError(
+      'Invalid package name specified with --name: ' +
+        scope.name +
+        '. It must be a valid npm package name.'
+    )
+  }
+
+  return scope
+}
+
+const argv = await getArgv()
+
+if (argv.help) showHelp(argv.__warn)
+
+const { createProjectFolder } = await import('../lib/create-project-folder.js')
+await createProjectFolder(argv)

package/lib/cli-pkg.js

@@ -0,0 +1,3 @@
+import cliPkg from '../package.json' with { type: 'json' }
+
+export { cliPkg }

package/lib/create-project-folder.js

@@ -0,0 +1,163 @@
+import { existsSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+
+import utils from './utils.js'
+import { runningPackageManager } from './running-pm.js'
+
+export async function createProjectFolder(scope) {
+  scope.meta = {
+    hasInstalledDeps: false,
+    installDepsCmd: null,
+    lintCmd: null,
+    runDevCmd: null
+  }
+
+  utils.prompts.intro('New Quasar Project')
+
+  await utils.promptUser(scope, {
+    template: () => {
+      const isPnpm =
+        scope.install === 'pnpm' ||
+        // invoked directly, not through a package manager's "create" command
+        !runningPackageManager ||
+        // invoked through "pnpm create quasar@latest"
+        runningPackageManager === 'pnpm'
+
+      return utils.prompts.select({
+        initialValue: utils.definitions.template.default,
+        message: 'What would you like to build?',
+        options: [
+          {
+            label: "App with Quasar CLI, let's go!",
+            value: 'app'
+          },
+          {
+            label: 'AppExtension for Quasar CLI',
+            value: 'ae',
+            hint: isPnpm
+              ? 'with PNPM only'
+              : 'PNPM only, run "pnpm create quasar@latest" instead',
+            disabled: !isPnpm
+          }
+        ]
+      })
+    },
+
+    projectFolder: async () => {
+      const val = await utils.prompts.text({
+        message: 'Project folder:',
+        placeholder: utils.definitions.projectFolder.default,
+        defaultValue: utils.definitions.projectFolder.default
+      })
+
+      utils.exitOnCancel(val)
+
+      const name = val.trim()
+      // inject the "short" name
+      scope.projectFolderName = name
+      return join(process.cwd(), name)
+    }
+  })
+
+  if (
+    !scope.overwrite &&
+    existsSync(scope.projectFolder) &&
+    readdirSync(scope.projectFolder).length !== 0
+  ) {
+    const val = await utils.prompts.confirm({
+      message:
+        (scope.projectFolderName === '.'
+          ? 'Current directory'
+          : `Target directory "${scope.projectFolderName}"`) +
+        ' is not empty. Remove existing files and continue?',
+      initialValue: false
+    })
+
+    utils.exitOnCancel(val)
+    if (val === false) utils.cancelScaffolding()
+
+    scope.overwrite = true
+  }
+
+  const { createQuasarScript } = await import(
+    `../templates/${scope.template}/create-quasar-script.js`
+  )
+  await createQuasarScript({ scope, utils })
+
+  await utils.promptUser(scope, {
+    install: () =>
+      utils.prompts.select({
+        message: 'Install project dependencies? (recommended)',
+        options: [
+          ...scope.packageManagerList.map(pm => ({
+            label: `Yes, use ${pm.toUpperCase()}`,
+            value: pm,
+            hint: pm === 'pnpm' || pm === 'yarn' ? 'recommended' : void 0
+          })),
+          { label: 'No, I will handle that myself', value: false }
+        ]
+      })
+  })
+
+  if (scope.install !== false) {
+    const hasInstalled = await utils.installDeps(scope)
+    if (hasInstalled) {
+      scope.meta.hasInstalledDeps = true
+
+      if (scope.preset.linting) {
+        await utils.lintFolder(scope)
+      }
+    }
+  }
+
+  const pkgManager = scope.install || scope.packageManagerList[0]
+  if (!scope.meta.hasInstalledDeps) {
+    scope.meta.installDepsCmd = `${pkgManager} install`
+
+    if (scope.preset.linting) {
+      scope.meta.lintCmd = `${pkgManager} run lint`
+    }
+  }
+
+  if (scope['no-git']) {
+    utils.prompts.log.info(
+      'Skipping git initialization as --no-git flag was provided'
+    )
+  } else {
+    utils.initializeGit(scope.projectFolder)
+  }
+
+  utils.prompts.note(
+    'Documentation → https://quasar.dev' +
+      '\nGithub → https://github.quasar.dev' +
+      '\nDiscussions → https://forum.quasar.dev' +
+      '\nDiscord → https://chat.quasar.dev' +
+      '\nDonations → https://donate.quasar.dev',
+    'Useful links:'
+  )
+
+  const cmdList = [
+    `cd ${scope.projectFolderName}`,
+    scope.meta.installDepsCmd,
+    scope.meta.lintCmd,
+    [scope.meta.runDevCmd, `${pkgManager} run dev`]
+      .filter(Boolean)
+      .join(' # or: ')
+  ]
+    .filter(Boolean)
+    .join('\n')
+
+  utils.prompts.note(cmdList, 'To get started:')
+
+  utils.prompts.note(
+    `Quasar is relying on donations to evolve.` +
+      `\nWe'd be very grateful if you can read our manifest ` +
+      `\non "Why donations are important": https://quasar.dev/why-donate` +
+      '\n\nDonation campaign: https://donate.quasar.dev' +
+      '\nAny amount is very welcome.' +
+      '\nIf invoices are required, please first contact Razvan Stoenescu.',
+    'Support Quasar Development:'
+  )
+
+  utils.prompts.outro('Done. Enjoy! - Quasar Team')
+}

package/lib/ensure-outside-project.js

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs'
+import { join, normalize, sep } from 'node:path'
+
+const quasarConfigFilenameList = [
+  'quasar.config.js',
+  'quasar.config.mjs',
+  'quasar.config.ts',
+  'quasar.config.cjs',
+  'quasar.conf.js' // legacy
+]
+
+export function isInsideQuasarProject() {
+  let dir = process.cwd()
+
+  while (dir.length !== 0 && dir.at(-1) !== sep) {
+    for (const name of quasarConfigFilenameList) {
+      const filename = join(dir, name)
+      if (existsSync(filename)) return true
+    }
+
+    dir = normalize(join(dir, '..'))
+  }
+
+  return false
+}

package/lib/running-pm.js

@@ -0,0 +1,2 @@
+const pm = process.env.npm_config_user_agent
+export const runningPackageManager = pm?.split(' ')[0].split('/')[0]