sugar-scripts 0.2.0-beta.0 → 1.0.0-beta.2

package/src/core/entry.ts

@@ -1,189 +0,0 @@
-import path from 'path';
-import {
-  Application,
-  Controller,
-  ControllerContext
-} from 'sugar-server';
-
-import {
-  CustomRender
-} from '../custom-config.type';
-
-export const ENTRIES_KEY = Symbol('_sugar_entries');
-export const ENTRIES_CONFIG_KEY = Symbol('_sugar_entries_config');
-
-export interface EntryConfig {
-  filePath: string
-}
-
-export interface EntriesController extends Controller {
-  [ENTRIES_KEY]: EntryConfig[]
-}
-
-const defaultRender: CustomRender = (
-  ctx,
-  entries,
-  custom
-) => {
-  return entries.toString();
-}
-
-const render: CustomRender = (
-  ...args
-) => {
-  let currentRender = defaultRender;
-  console.log('SUGAR_PROJECT_RENDER', process.env.SUGAR_PROJECT_RENDER)
-  if (process.env.SUGAR_PROJECT_RENDER) {
-    try {
-      currentRender = require(process.env.SUGAR_PROJECT_RENDER).default;
-      console.log('load custom render success');
-    } catch (e) {}
-  }
-  return currentRender(
-    ...args
-  )
-}
-
-// discuss：需要string[] 吗？
-export type RegisterFilePath = string | {[key: string]: string}
-
-export function register (
-  filePath: RegisterFilePath
-) {
-  return function (
-    target: Controller,
-    key: string,
-    descriptor: PropertyDescriptor
-  ) {
-    if (!Object.getOwnPropertyDescriptor(target, ENTRIES_KEY)) {
-      Object.defineProperty(target, ENTRIES_KEY, {
-        configurable: true,
-        enumerable: false,
-        writable: true,
-        value: []
-      })
-    }
-
-    if (typeof filePath === 'string') {
-      (target as EntriesController)[ENTRIES_KEY].push({
-        filePath
-      })
-    } else {
-      Object.keys(filePath).forEach((filePathKey) => {
-        const oneFilePath = filePath[filePathKey];
-        (target as EntriesController)[ENTRIES_KEY].push({
-          filePath: oneFilePath
-        })
-      })
-    }
-
-    const oldValue = descriptor.value;
-    descriptor.value = async function (
-      ctx: ControllerContext,
-      ...args: any
-    ) {
-      // ctx.app
-      let oldResult;
-      if (oldValue) {
-        oldResult = await oldValue.call(this, ...args);
-      }
-
-      let envEntries = ENV_ENTRIES;
-      if (
-        (ctx.app.constructor as any).ENTRIES
-      ) {
-        envEntries = (ctx.app.constructor as any).ENTRIES;
-      }
-      console.log('envEntries', envEntries, ENV_ENTRIES )
-
-      let entries: string[] | {[key: string]: string[]} = [];
-      if (typeof filePath === 'string') {
-        entries = envEntries[filePath] || [];
-      } else {
-        entries = Object.keys(filePath).reduce((
-          currentEntries,
-          filePathKey
-          ) => {
-            const oneFilePath = filePath[filePathKey];
-            currentEntries[filePathKey] = envEntries[oneFilePath];
-            return currentEntries;
-          }, {} as {[key: string]: string[]})
-      }
-
-      console.log(
-        'will search file',
-        envEntries,
-        filePath,
-        entries
-      )
-
-      return render(
-        ctx,
-        entries,
-        oldResult
-      );
-    }
-  }
-}
-
-export const ENTRY_WEBPACK_INJECT_KEY = 'ENTRY_WEBPACK_INJECT_KEY';
-
-export const ENV_ENTRIES = (process.env.SUGAR_PROJECT_ENTRIES || {}) as {
-  [entryKey: string]: string[]
-};
-
-export function getEntryUrl (
-  filePath: string
-) {
-  return '';
-}
-
-export function getEntries (
-  dirname: string
-) {
- let entries = {};
-
- require(
-   path.resolve(
-     dirname,
-     ''
-   )
- )
-}
-
-export function getEntriesFromController (
-  controller: Controller
-) {
-  return (controller as EntriesController)[ENTRIES_KEY] || [];
-}
-
-export function getEntriesFromControllers (
-  controllers: Controller[],
-  root: string
-) {
-  const entries: {
-    [key: string]: string
-  } = {};
-  controllers.forEach(
-    (controller) => {
-      getEntriesFromController(controller).forEach(({ filePath }) => {
-        entries[filePath] = path.resolve(
-          root,
-          filePath
-        )
-      })
-    }
-  )
-  return entries;
-}
-
-export function getEntriesFromApplicationClass (
-  ApplicationClass: typeof Application,
-  root: string
-) {
-  const app = new ApplicationClass();
-  return getEntriesFromControllers(
-    app.controllers,
-    root
-  )
-}

package/src/core/info.ts

@@ -1,5 +0,0 @@
-import {
-  router
-} from 'sugar-server';
-
-export const info = () => {}

package/src/core/init-running-context.ts

@@ -1,27 +0,0 @@
-import {
-  findProject,
-  findPackage
-} from '../shared/file-helpers';
-
-import {
-  SugarScriptsContext
-} from './running-context';
-
-export const initRunningContext = async (dir: string) => {
-  const {
-    root,
-    packageJson,
-    packageConfig
-  } = await findPackage(dir);
-  const { projectRoot, projectConfig } = await findProject(root);
-  if (!packageConfig || !projectConfig) {
-    throw new Error('')
-  }
-  return new SugarScriptsContext({
-    root,
-    packageName: packageJson.name,
-    packageConfig,
-    projectRoot,
-    projectConfig
-  })
-}

package/src/core/run-application.ts

@@ -1,12 +0,0 @@
-import {
-  Application
-} from 'sugar-server';
-
-export const runApplication = (
-  ApplicationClass: typeof Application,
-  port: number
-) => {
-  const app = new ApplicationClass();
-
-  app.listen(port)
-}

package/src/core/running-context.ts

@@ -1,92 +0,0 @@
-import { createHash } from 'crypto';
-import path from 'path';
-
-type BuildEntry = { [key: string]: string|string[] };
-
-interface PackageConfig {
-  browser?: {
-    /**
-     * 是否构建dll用的输出
-     */
-    dll?: boolean;
-    /**
-     * 输出目录
-     */
-    output: string;
-    /**
-     * controller/index
-     */
-    input?: string;
-    entry?: BuildEntry
-  };
-
-  server?: {
-    dll?: boolean;
-    output: string;
-    entry: string;
-    render?: string;
-  };
-}
-
-interface ProjectConfig {
-  cacheDir: string;
-}
-
-export function getHashFromRoot (
-  root: string
-) {
-  const hash = createHash('md5');
-  hash.update(root);
-  return `s_${hash.digest('hex')}`;
-}
-
-export class SugarScriptsContext {
-  root: string;
-  rootHash: string;
-  packageName: string;
-  packageConfig: PackageConfig;
-  projectRoot: string;
-  projectConfig: ProjectConfig;
-
-  constructor (
-    {
-      root,
-      packageName,
-      packageConfig,
-      projectRoot,
-      projectConfig
-    }: {
-      root: string;
-      packageName: string;
-      packageConfig: PackageConfig;
-      projectRoot: string;
-      projectConfig: ProjectConfig;
-    }
-  ) {
-    this.root = root;
-    this.packageName = packageName;
-    this.packageConfig = packageConfig;
-    this.projectRoot = projectRoot;
-    this.projectConfig = projectConfig;
-    this.rootHash = getHashFromRoot(root);
-  }
-
-  serverEntryName = 'main';
-
-  getStartFilePath () {
-    if (this.packageConfig.server) {
-      return path.resolve(
-        this.root,
-        this.packageConfig.server.output,
-        this.serverEntryName
-      )
-    }
-  }
-
-  getCacheDir () {
-    return path.resolve(
-      this.projectRoot,
-      this.projectConfig.cacheDir
-    )
-  }
-}

package/src/custom-config.type.ts

@@ -1,66 +0,0 @@
-import type {
-  ControllerContext
-} from 'sugar-server';
-import type WebpackChainConfig from 'webpack-chain';
-
-import {
-  SugarScriptsContext
-} from './core/running-context'
-
-export namespace SugarScriptsProject {
-  export type BrowserWebpackConfig = CustomWebpackConfig;
-
-  export type ServerWebpackConfig = CustomWebpackConfig;
-
-  export interface PackageConfig {
-    browser?: {
-      /**
-       * 是否构建dll用的输出
-       */
-      dll?: boolean;
-      /**
-       * 输出目录
-       */
-      output: string;
-      /**
-       * controller/index
-       */
-      input?: string;
-      entry?: BuildEntry
-    };
-
-    server?: {
-      dll?: boolean;
-      output: string;
-      entry: string;
-      render?: string;
-    };
-  }
-
-  export interface ProjectConfig {
-    cacheDir: string;
-  }
-
-
-  export interface CustomRender<C = any> {
-    (
-      ctx: ControllerContext,
-      entries: string[] | {[key: string]: string[]},
-      custom: C
-    ): string
-  };
-}
-
-type BuildEntry = { [key: string]: string|string[] };
-
-export type CustomWebpackConfig = (
-  webpackChainConfig: WebpackChainConfig,
-  context: SugarScriptsContext
-) => void;
-
-export type CustomRender<C = any> = (
-  ctx: ControllerContext,
-  entries: string[] | {[key: string]: string[]},
-  custom: C
-) => string;
-

package/src/shared/file-helpers.ts

@@ -1,192 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-import {
-  SUGAR_PACKAGE_CONFIG_FILENAME,
-  SUGAR_PROJECT_CONFIG_FILENAME
-} from '../constants';
-import {
-  SugarScriptsProject
-} from '../custom-config.type';
-// nodejs v10 支持
-// nodejs v14 才开始支持require('fs/promises')
-const fsPromises = fs.promises;
-
-export const searchFiles = async (
-  dir: string,
-  fileCheck: string | ((filePath: string) => boolean),
-  exclude?: string
-) => {
-  try {
-    await fsPromises.access(dir)
-  } catch (e) {
-    return [];
-  }
-  const files = await fsPromises.readdir(dir);
-  let currentFiles: string[] = [];
-
-  await Promise.all(
-    files.map(async (filename) => {
-      if (exclude === filename) return;
-      const fileOrDir = path.join(dir, filename);
-      const stats = await fsPromises.stat(fileOrDir);
-      if (stats.isFile()) {
-        if (typeof fileCheck === 'string') {
-          if (filename === fileCheck) {
-            currentFiles.push(fileOrDir)
-          }
-        } else if (fileCheck(fileOrDir)) {
-          currentFiles.push(fileOrDir)
-        }
-      } else if (stats.isDirectory()) {
-        const childCurrentFiles = await searchFiles(fileOrDir, fileCheck);
-        currentFiles = currentFiles.concat(childCurrentFiles);
-      }
-    })
-  )
-  return currentFiles;
-}
-
-export const findSiblingFile = async (
-  currentFilePath: string,
-  searchFileName: string
-) => {
-  const dir = path.dirname(currentFilePath);
-  const searchFilePath = path.join(dir, searchFileName);
-
-  const searchFileStat = await fsPromises.stat(searchFilePath);
-  if (searchFileStat.isFile()) {
-    return searchFilePath;
-  }
-
-  return null;
-}
-
-export const findParentFile = async (
-  currentFilePath: string,
-  searchFileName: string
-) => {
-  const dir = path.resolve(
-    path.dirname(currentFilePath),
-    '../'
-  );
-  const searchFilePath = path.join(dir, searchFileName);
-
-  const searchFileStat = await fsPromises.stat(searchFilePath);
-  if (searchFileStat.isFile()) {
-    return searchFilePath;
-  }
-
-  return null;
-}
-
-export const loadJSON = async (filePath: string) => {
-  try {
-    const contentBuffer = await fsPromises.readFile(filePath);
-    const content = contentBuffer.toString();
-
-    return JSON.parse(content);
-  } catch (e) {
-    return {};
-  }
-}
-
-export const writeFileSync = (
-  filePath: string,
-  data: string | NodeJS.ArrayBufferView
-) => {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true })
-  fs.writeFileSync(
-    filePath,
-    data
-  )
-}
-
-export const findPackage = async (dir: string): Promise<{
-  root: string;
-  packageJson: any;
-  packageConfig: SugarScriptsProject.PackageConfig | null;
-}> => {
-  const packagePath = path.resolve(dir, 'package.json');
-
-  let existed = true;
-  try {
-    await fsPromises.access(packagePath, fs.constants.F_OK);
-  } catch (e) {
-    existed = false;
-  }
-
-  let packageConfig = null;
-  try {
-    packageConfig = require(
-      path.resolve(dir, SUGAR_PACKAGE_CONFIG_FILENAME)
-    ).packageConfig;
-  } catch (e) {}
-
-  if (existed) {
-    return {
-      root: dir,
-      packageJson: require(
-        packagePath
-      ),
-      packageConfig
-    };
-  }
-
-  if (dir === '/') {
-    throw new Error('not found package.json');
-  }
-
-  return findPackage(
-    path.resolve(dir, '../')
-  )
-}
-
-export const findProject = async (dir: string): Promise<{
-  projectRoot: string,
-  projectConfig: SugarScriptsProject.ProjectConfig
-}> => {
-  const projectPath = path.resolve(dir, SUGAR_PROJECT_CONFIG_FILENAME);
-
-  let projectConfig = null;
-  try {
-    projectConfig = require(projectPath).projectConfig;
-  } catch (e) {}
-
-  if (dir === '/') {
-    throw new Error('not found sugar.project');
-  }
-
-  if (projectConfig) {
-    return {
-      projectRoot: dir,
-      projectConfig
-    };
-  }
-
-  return findProject(
-    path.resolve(dir, '../')
-  )
-}
-
-export const rm = async (filePath: string) => {
-  const stat = await fsPromises.stat(filePath);
-  if (
-    stat.isFile()
-    || stat.isSymbolicLink()
-  ) {
-    await fsPromises.unlink(filePath);
-    return;
-  }
-  if (stat.isDirectory()) {
-    const childFilePaths = await fsPromises.readdir(filePath);
-    await Promise.all(
-      childFilePaths.map((childFilePath) => (
-        rm(path.resolve(filePath, childFilePath))
-      ))
-    );
-    await fsPromises.rmdir(filePath);
-    return;
-  }
-}

package/src/typings.d.ts

@@ -1,8 +0,0 @@
-declare module 'babel-loader' {}
-
-declare module 'webpack-manifest-plugin' {
-  export class WebpackManifestPlugin {
-    constructor (options: any);
-    apply: any
-  }
-}

package/src/webpack/auto-entries.ts

@@ -1,5 +0,0 @@
-var a = require(process.env.SUGAR_PROJECT_REAL_ENTRY || '');
-
-a.default.ENTRIES = process.env.SUGAR_PROJECT_ENTRIES;
-
-export default a.default;

package/src/webpack/dll-dependencies-manifest-plugin.ts

@@ -1,115 +0,0 @@
-import webpack from 'webpack';
-
-import {
-  writeFileSync
-} from '../shared/file-helpers';
-
-export interface DllDependenciesManifestPluginOptions {
-  dllAssets: {
-    [dllName: string]: string[];
-  }
-  fileName: string,
-  generate: (entries: {
-    [entry: string]: string[]
-  }) => any
-}
-
-const PLUGIN_NAME = 'DllDependenciesManifestPlugin';
-
-export class DllDependenciesManifestPlugin {
-  options: DllDependenciesManifestPluginOptions;
-  constructor (options: DllDependenciesManifestPluginOptions) {
-    this.options = options;
-  }
-
-  apply (compiler: webpack.Compiler) {
-    const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
-
-    compiler.hooks.done.tap(
-      PLUGIN_NAME,
-      (stats) => {
-        var data = stats.toJson({
-          all: false,
-          entrypoints: true,
-          chunks: true,
-          chunkModules: true,
-          // nestedModules: true,
-          dependentModules: true,
-          moduleAssets: true,
-          assets: true,
-          modules: true,
-          // moduleTrace: true,
-          // reasons: true,
-          chunkRelations: true,
-          ids: true,
-          publicPath: true
-        })
-
-        const publicPath = data.publicPath;
-        const entries: {
-          [entry: string]: string[]
-        } = data.entrypoints
-          ? Object.keys(data.entrypoints).reduce((entries, entryKey) => {
-            entries[entryKey] = [];
-            const entryAssets = data.entrypoints![entryKey].assets;
-            if (entryAssets) {
-              const normalizePath = (path: string): string => {
-                if (!path.endsWith('/')) {
-                  return `${path}/`;
-                }
-
-                return path;
-              };
-
-              entries[entryKey] = entries[entryKey].concat(
-                entryAssets.map(({ name }) => (
-                  publicPath ? normalizePath(publicPath) + name : name
-                ))
-              )
-            };
-            return entries;
-          }, {} as {
-            [entry: string]: string[]
-          })
-          : {};
-
-        data.chunks?.forEach((chunk) => {
-          if (chunk.entry) {
-            let depDllAssets: string[] = [];
-            chunk.modules?.forEach((module) => {
-              if (
-                module.type !== 'module'
-                || !module.identifier
-              ) {
-                return;
-              }
-              const dllNameResult = /dll-reference (.+)$/.exec(module.identifier)
-              if (!dllNameResult) {
-                return;
-              }
-              const dllName = dllNameResult[1];
-              depDllAssets = depDllAssets.concat(
-                this.options.dllAssets[dllName]
-              )
-            })
-            if (entries[chunk.id as any]) {
-              entries[chunk.id as any] = depDllAssets.concat(entries[chunk.id as any])
-            }
-          }
-        })
-
-        // 去重复
-        Object.keys(entries).forEach((key) => {
-          entries[key] = Array.from(new Set(entries[key]))
-        })
-
-        const manifest = this.options.generate(entries);
-
-        writeFileSync(
-          this.options.fileName,
-          JSON.stringify(manifest, null, 2)
-        )
-      }
-    )
-  }
-}