@v4fire/core/config/default.js

V4Fire core library

'use strict';
require('dotenv').config();
require('./global');
const path = require('path'),
  upath = require('upath'),
  url = require('url');
const config = require('./config'),
  o = require('@v4fire/config/options').option;
const {
    config: pzlr,
    resolve
  } = require('@pzlr/build-core'),
  {
    env
  } = process;
module.exports = config.createConfig({
  dirs: [__dirname, 'client', 'server'],
  envs: {
    NODE_ENV: 'development'
  }
}, {
  __proto__: config,
  appName: o('app-name', {
    env: true,
    default: 'Default app',
    coerce(value) {
      globalThis['APP_NAME'] = value;
      return value;
    }
  }),
  locale: o('locale', {
    env: true,
    default: 'en',
    coerce(value) {
      globalThis['LOCALE'] = value;
      return value;
    }
  }),
  region: o('region', {
    env: true,
    coerce(value) {
      globalThis['REGION'] = value;
      return value;
    }
  }),
  environment: o('e', {
    env: true,
    short: 'e',
    default: env.NODE_ENV,
    coerce(value) {
      value = {
        prod: 'production',
        dev: 'development',
        stage: 'staging'
      }[value] || value;
      env.NODE_ENV = value;
      return value;
    }
  }),
  runtime() {
    return {
      prod: IS_PROD,
      debug: !IS_PROD,
      env: process.env.NODE_ENV,
      'core/helpers': true,
      'core/analytics': true,
      'core/log': true,
      'core/kv-storage': true,
      'core/session': true,
      'core/net': true,
      'prelude/date/relative': true,
      'prelude/date/format': true,
      'prelude/number/rounding': true,
      'prelude/number/format': true
    };
  },
  src: {
    include() {
      return require('../build/include')(this.roots);
    },
    cwd() {
      return this.roots[this.roots.length - 1] || resolve.cwd;
    },
    rel(path, ...args) {
      return upath.join(upath.relative(this.cwd(), this[path] ? this[path]() : path), ...args);
    },
    lib(...args) {
      return path.resolve(resolve.lib, ...args);
    },
    src(...args) {
      return path.resolve(resolve.sourceDir, ...args);
    },
    assets(...args) {
      return path.resolve(this.src(), pzlr.assets.dir, ...args);
    },
    output(...args) {
      const v = o('output', {
        env: true,
        default: 'dist'
      });
      return path.resolve(this.cwd(), v, ...args);
    },
    clientOutput(...args) {
      const v = o('client-output', {
        env: true,
        default: 'client'
      });
      return this.output(v, ...args);
    },
    serverOutput(...args) {
      const v = o('server-output', {
        env: true,
        default: 'server'
      });
      return this.output(v, ...args);
    },
    standaloneOutput(...args) {
      const v = o('standalone-output', {
        env: true,
        default: ''
      });
      return path.resolve(this.cwd(), 'lib', v, ...args);
    }
  },
  apiURL() {
    const {
      concatURLs
    } = require('../lib/core/url');
    return this.api.proxy ? concatURLs(this.api.pathname(), '/api') : this.api.url;
  },
  api: {
    proxy: o('api-proxy', {
      env: true,
      type: 'boolean',
      default: true
    }),
    url: o('api-url', {
      env: true,
      default: ''
    }),
    port: o('port', {
      env: true,
      type: 'number',
      default: 3333,
      validate(value) {
        return Number.isFinite(value) && value > 0 && value < 65536;
      }
    }),
    host() {
      const url = o('host-url', {
        env: true,
        default: 'http://localhost'
      });
      return `${url}:${this.port}/`;
    },
    pathname() {
      return o('base-path', {
        env: true,
        default: url.parse(this.host()).pathname || '/'
      });
    },
    schema: {}
  },
  build: {
    id() {
      return o('build-id', {
        env: true,
        default: (() => {
          if (!isProd) {
            const username = env.USER || env.USERNAME || 'unknown';
            return `debug version${username ? `, author: ${username}` : ''}`;
          }
          return null;
        })()
      });
    },
    hashAlg: 'md5',
    hashLength: 8,
    hash({
      data,
      alg = this.hashAlg,
      length = this.hashLength
    } = {}) {
      return this.config.hash({
        alg,
        length,
        data
      });
    }
  },
  es() {
    return o('es', {
      env: true,
      default: isProd ? 'ES6' : 'ES2019',
      coerce(value) {
        return value.toUpperCase();
      }
    });
  },
  babel() {
    return {
      plugins: [],
      compact: false
    };
  },
  typescript() {
    const es = this.es(),
      importHelpers = Boolean({
        ES3: true,
        ES5: true,
        ES6: true
      }[es]);
    return {
      transpileOnly: true,
      compilerOptions: {
        target: es,
        importHelpers
      }
    };
  },
  snakeskin() {
    return {
      pack: false,
      filters: {
        global: ['undef']
      },
      vars: {
        ...this.envs,
        appName: this.appName,
        locale: this.locale,
        version: include('package.json').version,
        buildVersion: this.build.id(),
        isProd
      }
    };
  },
  monic() {
    const runtime = this.runtime(),
      es = this.es();
    return {
      typescript: {
        flags: {
          runtime,
          es
        }
      },
      javascript: {
        flags: {
          runtime,
          es
        }
      }
    };
  }
});