expeditaea 1.0.0

package/packages/types/config/module.d.ts

@@ -0,0 +1,31 @@
+/**
+ * NuxtOptionsModule
+ * Documentation: https://nuxtjs.org/api/configuration-modules
+ *                https://nuxtjs.org/guide/modules
+ */
+
+import { Configuration as WebpackConfiguration } from 'webpack'
+import { NuxtOptionsLoaders } from './build'
+import { NuxtOptions } from '.'
+
+interface ExtendFunctionContext {
+  isClient: boolean
+  isDev: boolean
+  isLegacy: boolean
+  isModern: boolean
+  isServer: boolean
+  loaders: NuxtOptionsLoaders
+}
+
+type ExtendFunction = (config: WebpackConfiguration, ctx: ExtendFunctionContext) => void
+
+interface ModuleThis {
+  extendBuild(fn: ExtendFunction): void
+  options: NuxtOptions
+  nuxt: any // TBD
+  [key: string]: any // TBD
+}
+
+export type Module<T = any> = (this: ModuleThis, moduleOptions: T) => Promise<void> | void
+
+export type NuxtOptionsModule = string | Module | [string | Module, any]

package/packages/types/config/plugin.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NuxtOptionsPlugin
+ * Documentation: https://nuxtjs.org/api/configuration-plugins
+ *                https://nuxtjs.org/guide/plugins
+ */
+
+export type NuxtOptionsPlugin = { mode?: 'all' | 'client' | 'server', src: string, ssr?: boolean } | string

package/packages/types/config/render.d.ts

@@ -0,0 +1,76 @@
+/**
+ * NuxtOptionsRender
+ * Documentation: https://nuxtjs.org/api/configuration-render
+ *                https://ssr.vuejs.org/api/#renderer-options
+ *                https://github.com/expressjs/compression#readme
+ *                https://github.com/expressjs/serve-static#readme
+ *                https://github.com/jshttp/etag#readme
+ */
+
+import { ServerResponse } from 'http'
+import { CompressionOptions } from 'compression'
+import { IncomingMessage } from 'connect'
+import { Options as EtagOptions } from 'etag'
+import { ServeStaticOptions } from 'serve-static'
+import { BundleRendererOptions } from 'vue-server-renderer'
+import { NuxtOptionsServerMiddleware } from './server-middleware'
+
+type NuxtEtagOptions = EtagOptions & {
+  hash?: (html: string) => string
+}
+
+type ServePlaceholderHandler = 'default' | 'css' | 'html' | 'js' | 'json' | 'map' | 'plain' | 'image'
+interface ServePlaceholderOptions {
+  handlers?: Record<string, ServePlaceholderHandler | null | false>
+  mimes?: Record<ServePlaceholderHandler, string | false | undefined>
+  noCache?: boolean
+  placeholders?: Record<ServePlaceholderHandler, string | Buffer | false>
+  skipUnknown?: boolean
+  statusCode?: false | number
+}
+
+type CspPolicyName = 'child-src' | 'connect-src' | 'default-src' | 'font-src' | 'frame-src' | 'img-src' | 'manifest-src' | 'media-src' | 'object-src' | 'prefetch-src' | 'script-src' | 'script-src-elem' | 'script-src-attr' | 'style-src' | 'style-src-elem' | 'style-src-attr' | 'worker-src' | 'base-uri' | 'plugin-types' | 'sandbox' | 'form-action' | 'frame-ancestors' | 'navigate-to' | 'report-uri' | 'report-to' | 'block-all-mixed-content' | 'referrer' | 'require-sri-for' | 'trusted-types' | 'upgrade-insecure-requests'
+interface CspOptions {
+  addMeta?: boolean
+  allowedSources?: string[]
+  hashAlgorithm?: string
+  policies?: Partial<Record<CspPolicyName, string[]>>
+  reportOnly?: boolean
+  unsafeInlineCompatibility?: boolean
+}
+
+interface PreloadFile {
+  asType: 'script' | 'style' | 'font'
+  extension: string
+  file: string
+  fileWithoutQuery: string
+}
+
+export interface NuxtOptionsRender {
+  bundleRenderer?: BundleRendererOptions
+  compressor?: CompressionOptions | NuxtOptionsServerMiddleware | false
+  csp?: boolean | CspOptions
+  crossorigin?: 'anonymous' | 'use-credentials' | ''
+  dist?: ServeStaticOptions
+  etag?: NuxtEtagOptions | false
+  fallback?: {
+    dist?: ServePlaceholderOptions
+    static?: ServePlaceholderOptions
+  }
+  http2?: {
+    push?: boolean
+    shouldPush?: boolean
+    pushAssets?: (
+      req: IncomingMessage,
+      res: ServerResponse,
+      publicPath: string,
+      preloadFiles: PreloadFile[]
+    ) => string[]
+  }
+  injectScripts?: boolean
+  asyncScripts?: boolean
+  resourceHints?: boolean
+  ssr?: boolean
+  ssrLog?: boolean | 'collapsed'
+  static?: ServeStaticOptions
+}

package/packages/types/config/router.d.ts

@@ -0,0 +1,27 @@
+
+/**
+ * NuxtOptionsRouter
+ * Documentation: https://nuxtjs.org/api/configuration-router
+ *                https://router.vuejs.org/api/#router-construction-options
+ */
+
+import { RouterOptions, RouteConfig as _RouteConfig } from 'vue-router'
+
+type UnionToIntersection<T> = (T extends any ? (k: T) => void : never) extends ((k: infer U) => void) ? U : never
+type RouteConfig = UnionToIntersection<_RouteConfig>
+
+export interface NuxtRouteConfig extends Pick<RouteConfig, Exclude<keyof RouteConfig, 'children' | 'component'>> {
+  children?: NuxtRouteConfig[]
+  chunkName?: string
+  chunkNames?: Record<string, string>
+  component?: RouteConfig['component'] | string
+}
+
+export interface NuxtOptionsRouter extends RouterOptions {
+  routeNameSplitter?: string
+  extendRoutes?(routes: NuxtRouteConfig[], resolve: (...pathSegments: string[]) => string): void
+  linkPrefetchedClass?: string
+  middleware?: string | string[]
+  prefetchLinks?: boolean
+  trailingSlash?: boolean
+}

package/packages/types/config/runtime.d.ts

@@ -0,0 +1,15 @@
+/**
+* NuxtOptionsRuntimeConfig
+* NuxtRuntimeConfig interface can be extended by users to enable intellisense on $config
+*/
+
+export interface NuxtRuntimeConfig {
+  [key: string]: any;
+  /**
+   * This is used internally by Nuxt for dynamic configuration and should not be used.
+   * @internal
+   */
+  _app?: never;
+}
+
+export type NuxtOptionsRuntimeConfig = NuxtRuntimeConfig | ((env: typeof process.env) => NuxtRuntimeConfig)

package/packages/types/config/server-middleware.d.ts

@@ -0,0 +1,10 @@
+/**
+ * NuxtOptionsServerMiddleware
+ * Documentation: https://nuxtjs.org/api/configuration-servermiddleware
+ */
+
+import { NextHandleFunction } from 'connect'
+
+export type ServerMiddleware = NextHandleFunction
+
+export type NuxtOptionsServerMiddleware = string | { path: string, prefix?: boolean, handler: string | ServerMiddleware } | ServerMiddleware | Record<string, ServerMiddleware>

package/packages/types/config/server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * NuxtOptionsServer
+ * Documentation: https://nuxtjs.org/api/configuration-server
+ */
+
+export interface NuxtOptionsServer {
+  host?: string
+  https?: {
+    cert?: string | Buffer
+    key?: string | Buffer
+  }
+  port?: number | string
+  socket?: string
+  timing?: boolean | { total?: boolean }
+}

package/packages/types/config/vue-configuration.d.ts

@@ -0,0 +1,9 @@
+/**
+ * NuxtOptionsVueConfiguration
+ * Documentation: https://nuxtjs.org/api/configuration-vue-config
+ *                https://vuejs.org/v2/api/#Global-Config
+ */
+
+import { VueConstructor } from 'vue'
+
+export type NuxtOptionsVueConfiguration = Partial<VueConstructor['config']>

package/packages/types/config/watchers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * NuxtOptionsWatchers
+ * Documentation: https://nuxtjs.org/api/configuration-watchers
+ *                https://github.com/paulmillr/chokidar#api
+ *                https://webpack.js.org/configuration/watch/#watchoptions
+ */
+
+import { WatchOptions as ChokidarWatchOptions } from 'chokidar'
+import { WatchOptions as WebpackWatchOptions } from 'webpack'
+
+export type NuxtOptionsWatchers = {
+  chokidar?: ChokidarWatchOptions
+  webpack?: WebpackWatchOptions
+}

package/packages/types/index.d.ts

@@ -0,0 +1,11 @@
+import '@nuxt/components'
+import '@nuxt/telemetry'
+import './process'
+
+/**
+ * Note: `export * from './app'` does not work well with TypeScript < 3.9
+ * TODO: When 3.9 considered stable with Nuxt, require it and use `export *`
+ */
+
+export { Context, Middleware, NuxtAppOptions, NuxtError, Plugin, Transition } from './app'
+export { Configuration, Module, NuxtConfig, NuxtOptions, ServerMiddleware } from './config'

package/packages/types/index.js

@@ -0,0 +1 @@
+module.exports = {}

package/packages/types/package.js

@@ -0,0 +1,3 @@
+export default {
+  build: false
+}

package/packages/types/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@nuxt/types",
+  "version": "2.15.6",
+  "description": "Nuxt types",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "**/*.d.ts"
+  ],
+  "dependencies": {
+    "@types/autoprefixer": "9.7.2",
+    "@types/babel__core": "7.1.14",
+    "@types/compression": "1.7.0",
+    "@types/connect": "3.4.34",
+    "@types/etag": "1.8.0",
+    "@types/file-loader": "5.0.0",
+    "@types/html-minifier": "4.0.0",
+    "@types/less": "3.0.2",
+    "@types/node": "12.20.12",
+    "@types/optimize-css-assets-webpack-plugin": "5.0.3",
+    "@types/pug": "2.0.4",
+    "@types/sass-loader": "8.0.1",
+    "@types/serve-static": "1.13.9",
+    "@types/terser-webpack-plugin": "4.2.1",
+    "@types/webpack": "4.41.28",
+    "@types/webpack-bundle-analyzer": "3.9.3",
+    "@types/webpack-dev-middleware": "4.1.2",
+    "@types/webpack-hot-middleware": "2.25.4",
+    "sass-loader": "10.1.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/types/process.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extends NodeJS.Process interface
+ */
+
+declare namespace NodeJS {
+  interface Process {
+    browser: boolean
+    client: boolean
+    mode: 'spa' | 'universal'
+    modern: boolean
+    server: boolean
+    static: boolean
+  }
+}

package/packages/types/test/index.ts

@@ -0,0 +1,2 @@
+import './vue'
+import './process'

package/packages/types/test/process.ts

@@ -0,0 +1,17 @@
+/**
+ * Test extended type definitions of NodeJS Process interface
+ * @nuxt/types/process.d.ts
+ */
+
+process.browser = true
+
+process.client = true
+
+process.mode = 'spa'
+process.mode = 'universal'
+
+process.modern = true
+
+process.server = true
+
+process.static = true

package/packages/types/test/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "moduleResolution": "Node",
+    "strict": true,
+    "noEmit": true,
+    "lib": [
+      "ESNext",
+      "ESNext.AsyncIterable",
+      "DOM"
+    ]
+  }
+}

package/packages/types/test/vue.ts

@@ -0,0 +1,112 @@
+/**
+ * Test extended type definitions of Vue interfaces
+ * @nuxt/types/app/vue.d.ts
+ */
+
+import Vue, { ComponentOptions } from 'vue'
+import { Middleware } from '..'
+
+const options: ComponentOptions<Vue> = {}
+
+// asyncData
+
+options.asyncData = () => {
+  return {
+    foo: 'bar'
+  }
+}
+
+options.asyncData = () => undefined
+
+// fetch
+
+options.fetch = ({ store }) => {
+  return Promise.resolve('bar').then((res) => {
+    store.commit('setFoo', res)
+  })
+}
+
+options.fetch = async ({ store }) => {
+  const res = await Promise.resolve('bar')
+  store.commit('setFoo', res)
+}
+
+// key
+
+options.key = 'foo'
+options.key = to => to.fullPath
+
+// head
+
+const metaInfo = {
+  title: 'Home',
+  meta: [
+    { hid: 'description', name: 'description', content: 'My custom description' }
+  ]
+}
+
+options.head = metaInfo
+options.head = () => metaInfo
+
+// layout
+
+options.layout = 'foo'
+options.layout = () => 'foo'
+
+// loading
+
+options.loading = true
+
+// middleware
+
+const middlewares: Middleware[] = [
+  'foo',
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  () => {},
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async () => {}
+]
+
+options.middleware = middlewares
+options.middleware = middlewares[0]
+options.middleware = middlewares[1]
+options.middleware = middlewares[2]
+
+// scrollToTop
+
+options.scrollToTop = true
+
+// transition
+
+options.transition = 'foo'
+options.transition = { name: 'foo' }
+options.transition = () => 'foo'
+options.transition = () => {
+  return { name: 'foo' }
+}
+
+// validate
+
+options.validate = () => true
+options.validate = async () => {
+  const valid = await Promise.resolve(true)
+  return valid
+}
+
+// watchQuery
+
+options.watchQuery = true
+options.watchQuery = ['foo', 'bar']
+
+// $nuxt
+
+const vm = new Vue(options)
+
+if (vm.$nuxt.$loading.fail) { vm.$nuxt.$loading.fail() }
+vm.$nuxt.$loading.finish()
+if (vm.$nuxt.$loading.increase) { vm.$nuxt.$loading.increase(1) }
+if (vm.$nuxt.$loading.pause) { vm.$nuxt.$loading.pause() }
+vm.$nuxt.$loading.start()
+
+vm.$nuxt.isOffline = true
+vm.$nuxt.isOnline = true

package/packages/utils/package.js

@@ -0,0 +1,3 @@
+export default {
+  build: true
+}

package/packages/utils/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@nuxt/utils",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/utils.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "consola": "^2.15.3",
+    "create-require": "^1.1.1",
+    "fs-extra": "^9.1.0",
+    "hash-sum": "^2.0.0",
+    "jiti": "^1.9.2",
+    "lodash": "^4.17.21",
+    "proper-lockfile": "^4.1.2",
+    "semver": "^7.3.5",
+    "serialize-javascript": "^5.0.1",
+    "signal-exit": "^3.0.3",
+    "ua-parser-js": "^0.7.28",
+    "ufo": "^0.7.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/utils/src/cjs.js

@@ -0,0 +1,98 @@
+import { join } from 'path'
+import _createRequire from 'create-require'
+import jiti from 'jiti'
+
+export const createRequire = (filename, useJiti = global.__NUXT_DEV__) => {
+  if (useJiti && typeof jest === 'undefined') {
+    return jiti(filename)
+  }
+
+  return _createRequire(filename)
+}
+
+const _require = createRequire()
+
+export function isHMRCompatible (id) {
+  return !/[/\\]mongoose[/\\/]/.test(id)
+}
+
+export function isExternalDependency (id) {
+  return /[/\\]node_modules[/\\]/.test(id)
+}
+
+export function clearRequireCache (id) {
+  if (isExternalDependency(id) && isHMRCompatible(id)) {
+    return
+  }
+
+  const entry = getRequireCacheItem(id)
+
+  if (!entry) {
+    delete _require.cache[id]
+    return
+  }
+
+  if (entry.parent) {
+    entry.parent.children = entry.parent.children.filter(e => e.id !== id)
+  }
+
+  // Needs to be cleared before children, to protect against circular deps (#7966)
+  delete _require.cache[id]
+
+  for (const child of entry.children) {
+    clearRequireCache(child.id)
+  }
+}
+
+export function scanRequireTree (id, files = new Set()) {
+  if (isExternalDependency(id) || files.has(id)) {
+    return files
+  }
+
+  const entry = getRequireCacheItem(id)
+
+  if (!entry) {
+    files.add(id)
+    return files
+  }
+
+  files.add(entry.id)
+
+  for (const child of entry.children) {
+    scanRequireTree(child.id, files)
+  }
+
+  return files
+}
+
+export function getRequireCacheItem (id) {
+  try {
+    return _require.cache[id]
+  } catch (e) {
+  }
+}
+
+export function resolveModule (id, paths) {
+  if (typeof paths === 'string') {
+    paths = [paths]
+  }
+  return _require.resolve(id, {
+    paths: [].concat(...(global.__NUXT_PREPATHS__ || []), paths || [], global.__NUXT_PATHS__ || [], process.cwd())
+  })
+}
+
+export function requireModule (id, paths) {
+  return _require(resolveModule(id, paths))
+}
+
+export function tryRequire (id, paths) {
+  try { return requireModule(id, paths) } catch (e) { }
+}
+
+export function tryResolve (id, paths) {
+  try { return resolveModule(id, paths) } catch (e) { }
+}
+
+export function getPKG (id, paths) {
+  return tryRequire(join(id, 'package.json'), paths)
+}

package/packages/utils/src/constants.js

@@ -0,0 +1,9 @@
+export const TARGETS = {
+  server: 'server',
+  static: 'static'
+}
+
+export const MODES = {
+  universal: 'universal',
+  spa: 'spa'
+}

package/packages/utils/src/context.js

@@ -0,0 +1,21 @@
+import { TARGETS } from './constants'
+
+export const getContext = function getContext (req, res) {
+  return { req, res }
+}
+
+export const determineGlobals = function determineGlobals (globalName, globals) {
+  const _globals = {}
+  for (const global in globals) {
+    if (typeof globals[global] === 'function') {
+      _globals[global] = globals[global](globalName)
+    } else {
+      _globals[global] = globals[global]
+    }
+  }
+  return _globals
+}
+
+export const isFullStatic = function (options) {
+  return !options.dev && !options._legacyGenerate && options.target === TARGETS.static && options.render.ssr
+}

package/packages/utils/src/index.js

@@ -0,0 +1,11 @@
+export * from './context'
+export * from './lang'
+export * from './locking'
+export * from './resolve'
+export * from './route'
+export * from './serialize'
+export * from './task'
+export * from './timer'
+export * from './cjs'
+export * from './modern'
+export * from './constants'

package/packages/utils/src/lang.js

@@ -0,0 +1,40 @@
+import { hasProtocol, joinURL } from 'ufo'
+
+export const encodeHtml = function encodeHtml (str) {
+  return str.replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+export const isString = obj => typeof obj === 'string' || obj instanceof String
+
+export const isNonEmptyString = obj => Boolean(obj && isString(obj))
+
+export const isPureObject = obj => !Array.isArray(obj) && typeof obj === 'object'
+
+export const isUrl = function isUrl (url) {
+  return hasProtocol(url, true)
+}
+
+export const urlJoin = joinURL
+
+/**
+ * Wraps value in array if it is not already an array
+ *
+ * @param  {any} value
+ * @return {array}
+ */
+export const wrapArray = value => Array.isArray(value) ? value : [value]
+
+const WHITESPACE_REPLACEMENTS = [
+  [/[ \t\f\r]+\n/g, '\n'], // strip empty indents
+  [/{\n{2,}/g, '{\n'], // strip start padding from blocks
+  [/\n{2,}([ \t\f\r]*})/g, '\n$1'], // strip end padding from blocks
+  [/\n{3,}/g, '\n\n'], // strip multiple blank lines (1 allowed)
+  [/\n{2,}$/g, '\n'] // strip blank lines EOF (0 allowed)
+]
+
+export const stripWhitespace = function stripWhitespace (string) {
+  WHITESPACE_REPLACEMENTS.forEach(([regex, newSubstr]) => {
+    string = string.replace(regex, newSubstr)
+  })
+  return string
+}